1500 lines
53 KiB
C#
1500 lines
53 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
namespace EasyChart
|
|
{
|
|
public enum CoordinateSystemType
|
|
{
|
|
Cartesian2D,
|
|
Polar2D,
|
|
None
|
|
}
|
|
|
|
public enum AxisId
|
|
{
|
|
XBottom,
|
|
XTop,
|
|
YLeft,
|
|
YRight
|
|
}
|
|
|
|
public enum AxisType
|
|
{
|
|
Category,
|
|
Value
|
|
}
|
|
|
|
public enum CategoryLabelPlacement
|
|
{
|
|
Tick,
|
|
CellCenter
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class CartesianMapping
|
|
{
|
|
public AxisId xAxisId = AxisId.XBottom;
|
|
public AxisId yAxisId = AxisId.YLeft;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PlotLayoutSettings
|
|
{
|
|
public Vector2 centerOffset = Vector2.zero;
|
|
public float padding = 10f;
|
|
public float labelRadialOffset = 0f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class LabelStyleSettings
|
|
{
|
|
public bool enabled = true;
|
|
public int fontSize = 10;
|
|
public Color color = Color.white;
|
|
public LabelPosition position = LabelPosition.Outside;
|
|
public Vector2 offset = Vector2.zero;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class AxisConfig
|
|
{
|
|
public AxisId id;
|
|
public AxisType axisType = AxisType.Value;
|
|
|
|
public List<string> labels = new List<string>();
|
|
|
|
public bool visible = true;
|
|
public Color color = Color.white;
|
|
public float width = 2.0f;
|
|
|
|
public LabelStyleSettings labelStyle;
|
|
|
|
public bool showLabels = true;
|
|
public int fontSize = 10;
|
|
public Color labelColor = Color.white;
|
|
public LabelPosition labelPosition = LabelPosition.Outside;
|
|
[InspectorName("LabelPlacement")]
|
|
public CategoryLabelPlacement labelPlacement = CategoryLabelPlacement.Tick;
|
|
public Vector2 labelOffset = Vector2.zero;
|
|
public bool autoRangeMin = true;
|
|
public bool autoRangeMax = true;
|
|
public AutoRangeRoundingMode autoRangeRounding = AutoRangeRoundingMode.Tens;
|
|
public float autoRangeUnit = 1f;
|
|
public float minValue = 0f;
|
|
public float maxValue = 1f;
|
|
|
|
public bool autoTicks = true;
|
|
public int splitCount = 5;
|
|
public string labelFormat;
|
|
|
|
public bool categoryAutoScroll = false;
|
|
public bool categorySmoothScroll = true;
|
|
public float categoryScrollInterval = 1.0f;
|
|
public int categoryScrollStep = 1;
|
|
|
|
public bool showUnit = false;
|
|
public string unitText;
|
|
public LabelStyleSettings unitLabelStyle;
|
|
}
|
|
|
|
public enum AutoRangeRoundingMode
|
|
{
|
|
None,
|
|
Integer,
|
|
Tens,
|
|
Hundreds,
|
|
Custom
|
|
}
|
|
|
|
public enum SerieType
|
|
{
|
|
// 折线图：适合展示随时间/类别变化的趋势（连续变化）。常用度：★★★★★ 难度：★★☆☆☆
|
|
Line = 0,
|
|
// 柱状图：适合展示分类对比（离散类别），强调数量大小。常用度：★★★★★ 难度：★★☆☆☆
|
|
Bar = 1,
|
|
// 饼图：适合展示占比构成（总量=100%），不适合类别过多。常用度：★★★★☆ 难度：★★★☆☆
|
|
Pie = 2,
|
|
// 散点图：适合展示二维数据分布、相关性（x-y 点）。常用度：★★★★☆ 难度：★★★☆☆
|
|
Scatter = 4,
|
|
// 雷达图：适合展示多维指标对比（同一维度尺度下的多项指标）。常用度：★★★☆☆ 难度：★★★★☆
|
|
Radar = 5,
|
|
// 环形图：饼图的变体，可在中心留空用于显示总量/标题等。常用度：★★★☆☆ 难度：★★★☆☆
|
|
RingChart = 6,
|
|
// 热力图：适合展示二维矩阵强度/密度（例如日历热力、相关矩阵等）。常用度：★★★☆☆ 难度：★★★★☆
|
|
Heatmap = 7,
|
|
// 仪表盘：展示单一指标当前值/区间（类似速度表）。常用度：★★☆☆☆ 难度：★★★☆☆
|
|
Gauge = 8,
|
|
// 横向柱状图：与柱状图类似，但横向布局更适合长标签类别。常用度：★★★★☆ 难度：★★☆☆☆
|
|
HorizontalBar = 9,
|
|
// K 线图：金融蜡烛图（开/高/低/收），用于行情走势。常用度：★★☆☆☆ 难度：★★★★★
|
|
Candlestick = 21,
|
|
// OHLC 图：与 K 线类似，用线段表示开高低收（更简洁）。常用度：★★☆☆☆ 难度：★★★★★
|
|
OHLC = 22,
|
|
// 箱线图：展示分布统计（四分位数、中位数、异常值）。常用度：★★☆☆☆ 难度：★★★★★
|
|
BoxPlot = 23,
|
|
// 直方图：展示单变量分布（分箱计数）。常用度：★★★☆☆ 难度：★★★☆☆
|
|
Histogram = 24,
|
|
// 瀑布图：展示从起点到终点的增减构成（正负贡献）。常用度：★★☆☆☆ 难度：★★★★☆
|
|
Waterfall = 25,
|
|
// 漏斗图：展示流程转化/阶段漏损（例如注册→下单→支付）。常用度：★★☆☆☆ 难度：★★★☆☆
|
|
Funnel = 26,
|
|
// 桑基图：展示流量/能量/资金流向与分配（有向流图）。常用度：★☆☆☆☆ 难度：★★★★★（不适合用当前 SeriesData，需图结构/边数据，先注释）
|
|
// Sankey = 30,
|
|
// 矩形树图：用矩形面积展示层级与占比（适合层级占比对比）。常用度：★☆☆☆☆ 难度：★★★★★（不适合用当前 SeriesData，需层级节点数据，先注释）
|
|
// TreeMap = 31,
|
|
// 旭日图：环形层级占比图（层级结构的构成展示）。常用度：★☆☆☆☆ 难度：★★★★★（不适合用当前 SeriesData，需层级节点数据，先注释）
|
|
// Sunburst = 32,
|
|
// 弦图：展示类别之间的关联/流量（成对关系强度）。常用度：★☆☆☆☆ 难度：★★★★★（不适合用当前 SeriesData，需矩阵/边数据，先注释）
|
|
// Chord = 33,
|
|
// 3D 饼图：饼图的三维表现形式（通常属于 Pro 扩展）。常用度：★☆☆☆☆ 难度：★★★★★
|
|
Pie3D = 100,
|
|
// 3D 柱状图：三维柱形对比（可能用于二维分类 + 数值）。常用度：★☆☆☆☆ 难度：★★★★★
|
|
Bar3D = 101,
|
|
// 3D 折线图：三维折线/轨迹展示（z 维度叠加）。常用度：★☆☆☆☆ 难度：★★★★★
|
|
Line3D = 102,
|
|
// 3D 散点图：三维坐标点分布（x,y,z）。常用度：★☆☆☆☆ 难度：★★★★★
|
|
Scatter3D = 103,
|
|
|
|
}
|
|
|
|
[System.Serializable]
|
|
public abstract class BaseSerieSettings
|
|
{
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PointSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool show = true;
|
|
public float size = 4.0f;
|
|
|
|
[InspectorName("Texture")]
|
|
public TextureFillSettings textureFill = new TextureFillSettings();
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings();
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings();
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class TextureMappingSettings
|
|
{
|
|
public Texture2D texture;
|
|
public Vector2 tiling = Vector2.one;
|
|
public Vector2 offset = Vector2.zero;
|
|
}
|
|
|
|
public enum TextureFillAnimationType
|
|
{
|
|
None = 0,
|
|
TextureUvMove = 1,
|
|
TextureScale = 2,
|
|
TextureFade = 3
|
|
}
|
|
|
|
public enum TextureFillScaleType
|
|
{
|
|
ZoomIn = 0,
|
|
ZoomOut = 1,
|
|
Sin = 2,
|
|
PingPong = 3
|
|
}
|
|
|
|
public enum TextureFillColorOverLifeWrap
|
|
{
|
|
Loop = 0,
|
|
PingPong = 1,
|
|
Clamp = 2
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class TextureFillSettings : ISerializationCallbackReceiver
|
|
{
|
|
public Texture2D texture;
|
|
public Vector2 tiling = Vector2.one;
|
|
public Vector2 offset = Vector2.zero;
|
|
public Color color = Color.white;
|
|
|
|
public TextureFillAnimationType animationType = TextureFillAnimationType.None;
|
|
|
|
public Vector2 uvMoveSpeed = Vector2.zero;
|
|
|
|
public TextureFillScaleType scaleType = TextureFillScaleType.Sin;
|
|
public float scaleSpeed = 1f;
|
|
|
|
public Vector2 scaleFrom = Vector2.one;
|
|
public Vector2 scaleTo = new Vector2(1.2f, 1.2f);
|
|
public Color colorFadeStart = Color.white;
|
|
public Color colorFadeEnd = new Color(1f, 1f, 1f, 0f);
|
|
public float colorFadeSpeed = 1f;
|
|
|
|
public TextureFillColorOverLifeWrap colorFadeWrap = TextureFillColorOverLifeWrap.PingPong;
|
|
public Gradient colorFadeGradient;
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (colorFadeGradient == null)
|
|
{
|
|
colorFadeGradient = new Gradient();
|
|
colorFadeGradient.SetKeys(
|
|
new[]
|
|
{
|
|
new GradientColorKey(colorFadeStart, 0f),
|
|
new GradientColorKey(colorFadeEnd, 1f)
|
|
},
|
|
new[]
|
|
{
|
|
new GradientAlphaKey(colorFadeStart.a, 0f),
|
|
new GradientAlphaKey(colorFadeEnd.a, 1f)
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class SeriesData
|
|
{
|
|
public string id;
|
|
public float x;
|
|
public float value;
|
|
public float y;
|
|
public float z;
|
|
public string name;
|
|
public bool useColor = false;
|
|
public Color color = Color.white;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class SizeMappingSettings
|
|
{
|
|
public bool enabled = false;
|
|
public float minValue = 0f;
|
|
public float maxValue = 1f;
|
|
public float minSize = 4f;
|
|
public float maxSize = 12f;
|
|
public bool clamp = true;
|
|
public AnimationCurve curve = AnimationCurve.Linear(0, 0, 1, 1);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class HoverHighlightSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool enabled = false;
|
|
[SerializeField, HideInInspector]
|
|
private float _scale = 1.5f;
|
|
|
|
[SerializeField, HideInInspector]
|
|
private TextureFillSettings _textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
|
|
public float scale
|
|
{
|
|
get => _scale;
|
|
set => _scale = value;
|
|
}
|
|
|
|
public TextureFillSettings textureFill
|
|
{
|
|
get => _textureFill;
|
|
set => _textureFill = value;
|
|
}
|
|
|
|
public float pickRadius = 8f;
|
|
|
|
public PointSettings point = new PointSettings();
|
|
|
|
public Color lineColor = new Color(1f, 1f, 1f, 0.35f);
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (_textureFill == null) _textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
if (point == null) point = new PointSettings();
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (_textureFill == null) _textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
if (point == null) point = new PointSettings();
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BarHoverSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool enabled = false;
|
|
public float pickRadius = 8f;
|
|
public float scale = 1.5f;
|
|
public TextureFillSettings textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.35f) };
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class LineStrokeSettings
|
|
{
|
|
public LineType lineType = LineType.Straight;
|
|
public float width = 2.0f;
|
|
public Color color = Color.white;
|
|
|
|
[InspectorName("Texture")]
|
|
public TextureFillSettings textureFill = new TextureFillSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class AreaFillSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool show = false;
|
|
|
|
[InspectorName("Texture")]
|
|
public TextureFillSettings textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.2f) };
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.2f) };
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.2f) };
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BorderSettings
|
|
{
|
|
public float width = 0f;
|
|
public Color color = new Color(0, 0, 0, 0);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BackgroundSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool show = false;
|
|
|
|
[InspectorName("Texture")]
|
|
public TextureFillSettings textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.08f) };
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.08f) };
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings { color = new Color(1, 1, 1, 0.08f) };
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class LineSettings : BaseSerieSettings
|
|
{
|
|
[Header("Stroke")]
|
|
[InspectorName("Stroke")]
|
|
public LineStrokeSettings stroke = new LineStrokeSettings();
|
|
|
|
[Header("Point")]
|
|
public PointSettings point = new PointSettings();
|
|
|
|
[Header("Hover")]
|
|
public HoverHighlightSettings hover = new HoverHighlightSettings();
|
|
|
|
[Header("Area")]
|
|
public AreaFillSettings area = new AreaFillSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class ScatterSettings : BaseSerieSettings
|
|
{
|
|
[Header("Point")]
|
|
public PointSettings point = new PointSettings();
|
|
|
|
public SizeMappingSettings sizeMapping = new SizeMappingSettings();
|
|
|
|
public HoverHighlightSettings hover = new HoverHighlightSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class HeatmapSettings : BaseSerieSettings
|
|
{
|
|
public enum RenderMode
|
|
{
|
|
[Tooltip("Discrete cell-based rendering with sharp boundaries")]
|
|
Grid,
|
|
[Tooltip("Smooth pixel-based rendering using Gaussian interpolation")]
|
|
Gradient,
|
|
[Tooltip("Contour lines with optional filled regions")]
|
|
Contour
|
|
}
|
|
|
|
public enum InfluenceMode
|
|
{
|
|
[Tooltip("No influence spreading between cells")]
|
|
None,
|
|
[Tooltip("Values bleed into neighboring cells with falloff")]
|
|
Bleed,
|
|
[Tooltip("Gaussian smoothing applied to the grid")]
|
|
Smooth
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BleedSettings
|
|
{
|
|
[Tooltip("Number of cells the influence spreads to")]
|
|
public int radiusCells = 1;
|
|
[Tooltip("Number of discrete falloff steps")]
|
|
public int steps = 6;
|
|
[Tooltip("Strength of the bleed effect (0-1)")]
|
|
[Range(0f, 1f)]
|
|
public float strength = 0.35f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class SmoothSettings
|
|
{
|
|
[Tooltip("Radius of the smoothing kernel in cells")]
|
|
public int radiusCells = 1;
|
|
[Tooltip("Number of smoothing passes to apply")]
|
|
public int passes = 1;
|
|
[Tooltip("Standard deviation of the Gaussian kernel")]
|
|
public float sigma = 1f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class GradientSettings
|
|
{
|
|
[Tooltip("Texture resolution for gradient rendering (higher = smoother but slower)")]
|
|
public int resolution = 256;
|
|
[Tooltip("Gaussian kernel sigma for density estimation (larger = smoother blending)")]
|
|
public float sigma = 30f;
|
|
[Tooltip("Contrast adjustment: higher values increase contrast (sharper peaks), lower values spread colors more evenly")]
|
|
public float intensity = 1f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class ContourSettings
|
|
{
|
|
[Tooltip("Number of contour levels to generate")]
|
|
public int levels = 10;
|
|
[Tooltip("Width of contour lines in pixels")]
|
|
public float lineWidth = 1f;
|
|
[Tooltip("Show filled regions between contour lines")]
|
|
public bool showFill = true;
|
|
[Tooltip("Show contour lines")]
|
|
public bool showLines = true;
|
|
[Tooltip("Color of the contour lines")]
|
|
public Color lineColor = new Color(0.2f, 0.2f, 0.2f, 0.8f);
|
|
}
|
|
|
|
[Tooltip("Rendering mode: Grid (discrete cells), Gradient (smooth interpolation), or Contour (isolines)")]
|
|
public RenderMode renderMode = RenderMode.Grid;
|
|
|
|
[Tooltip("Gap between cells in pixels (Grid mode only)")]
|
|
public float cellGapPx = 1f;
|
|
|
|
[Tooltip("Number of horizontal cells when using Value axis type")]
|
|
public int xSplitCount = 10;
|
|
[Tooltip("Number of vertical cells when using Value axis type")]
|
|
public int ySplitCount = 10;
|
|
|
|
[Tooltip("Automatically calculate value range from data")]
|
|
public bool autoRange = true;
|
|
[Tooltip("Minimum value for color mapping (when autoRange is off)")]
|
|
public float minValue = 0f;
|
|
[Tooltip("Maximum value for color mapping (when autoRange is off)")]
|
|
public float maxValue = 1f;
|
|
|
|
[Tooltip("How cell values influence neighboring cells (Grid mode only)")]
|
|
public InfluenceMode influenceMode = InfluenceMode.None;
|
|
[Tooltip("Settings for Bleed influence mode")]
|
|
public BleedSettings bleed = new BleedSettings();
|
|
[Tooltip("Settings for Smooth influence mode")]
|
|
public SmoothSettings smooth = new SmoothSettings();
|
|
[Tooltip("Settings for Gradient render mode")]
|
|
public GradientSettings gradient = new GradientSettings();
|
|
[Tooltip("Settings for Contour render mode")]
|
|
public ContourSettings contour = new ContourSettings();
|
|
|
|
[Tooltip("Clamp values to min/max range before color mapping")]
|
|
public bool clamp = true;
|
|
[Tooltip("Color for minimum values")]
|
|
public Color lowColor = new Color(0f, 0.55f, 1f, 1f);
|
|
[Tooltip("Color for middle values (used for interpolation)")]
|
|
public Color midColor = Color.white;
|
|
[Tooltip("Color for maximum values")]
|
|
public Color highColor = new Color(1f, 0.25f, 0.25f, 1f);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class RadarSettings : BaseSerieSettings
|
|
{
|
|
[System.Serializable]
|
|
public class RadarLayoutSettings
|
|
{
|
|
public float startAngleDeg = -90f;
|
|
public bool clockwise = true;
|
|
|
|
public float innerRadius = 0f;
|
|
public float outerRadius = 0f;
|
|
|
|
public PlotLayoutSettings plot = new PlotLayoutSettings();
|
|
|
|
public TextureFillSettings background = new TextureFillSettings { color = new Color(0.2f, 0.2f, 0.2f, 0.3f) };
|
|
}
|
|
|
|
[Header("Radar")]
|
|
public RadarLayoutSettings radar = new RadarLayoutSettings();
|
|
|
|
[Header("LineStroke")]
|
|
[InspectorName("LineStroke")]
|
|
public LineStrokeSettings stroke = new LineStrokeSettings();
|
|
|
|
[Header("Area")]
|
|
public AreaFillSettings area = new AreaFillSettings { show = true, textureFill = new TextureFillSettings { color = new Color(1f, 1f, 1f, 0.2f) } };
|
|
|
|
[Header("Point")]
|
|
public PointSettings point = new PointSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class BarSettings : BaseSerieSettings, ISerializationCallbackReceiver
|
|
{
|
|
public float barWidth = 10f;
|
|
|
|
[InspectorName("Texture")]
|
|
public TextureFillSettings textureFill = new TextureFillSettings();
|
|
|
|
public bool stacked = false;
|
|
|
|
public float cornerRadius = 0f;
|
|
public int cornerSegments = 4;
|
|
|
|
public string stackGroup = "";
|
|
public float barGap = 2f;
|
|
public float categoryGap = 0f;
|
|
|
|
public BorderSettings border = new BorderSettings();
|
|
|
|
public BackgroundSettings background = new BackgroundSettings();
|
|
|
|
public BarHoverSettings hover = new BarHoverSettings();
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings();
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (textureFill == null) textureFill = new TextureFillSettings();
|
|
|
|
if (hover == null) hover = new BarHoverSettings();
|
|
hover.OnAfterDeserialize();
|
|
}
|
|
}
|
|
|
|
public enum SliceGapType
|
|
{
|
|
Radial,
|
|
Translate,
|
|
Uniform
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PieLayoutSettings
|
|
{
|
|
public float startAngleDeg = -90f;
|
|
public bool clockwise = true;
|
|
public float angleRangeDeg = 360f;
|
|
|
|
public float innerRadius = 0f;
|
|
public Color innerRadiusColor = new Color(0, 0, 0, 0);
|
|
public float cornerRadius = 0f;
|
|
public float sliceGapPx = 0f;
|
|
public SliceGapType sliceGapType = SliceGapType.Radial;
|
|
public float outerRadius = 0f;
|
|
|
|
public PlotLayoutSettings plot = new PlotLayoutSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class RingSettings
|
|
{
|
|
public bool showBackground = false;
|
|
public float backgroundAlpha = 0.25f;
|
|
public Color backgroundColor = new Color(0, 0, 0, 0);
|
|
public float cornerRadius = 0f;
|
|
public float ringGapPx = 0f;
|
|
}
|
|
|
|
public enum PieLegendSource
|
|
{
|
|
Slice,
|
|
RingSlice,
|
|
Series
|
|
}
|
|
|
|
public enum ValueDisplayStyle
|
|
{
|
|
None,
|
|
Parentheses,
|
|
AlignedColumns
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PieLegendSettings
|
|
{
|
|
[HideInInspector] public bool overrideEnabled = false;
|
|
public PieLegendSource source = PieLegendSource.Slice;
|
|
|
|
public bool enabled = true;
|
|
[HideInInspector] public bool showValue = false;
|
|
public ValueDisplayStyle valueDisplayStyle = ValueDisplayStyle.None;
|
|
public LegendPosition position = LegendPosition.Bottom;
|
|
public int fontSize = 12;
|
|
public Color color = Color.white;
|
|
public Color backgroundColor = new Color(0, 0, 0, 0);
|
|
public float itemSpacing = 10f;
|
|
public Vector2 offset = Vector2.zero;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PieSettings : BaseSerieSettings
|
|
{
|
|
public bool sortByValue = false;
|
|
public PieLayoutSettings layout = new PieLayoutSettings();
|
|
public PieHoverSettings hover = new PieHoverSettings();
|
|
public PieAggregationSettings aggregation = new PieAggregationSettings();
|
|
public RingSettings ring = new RingSettings();
|
|
public PieLegendSettings legend = new PieLegendSettings();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class RingChartLayoutSettings
|
|
{
|
|
public float startAngleDeg = -90f;
|
|
public bool clockwise = true;
|
|
public float angleRangeDeg = 360f;
|
|
public float innerRadius = 0.3f;
|
|
public float outerRadius = 0f;
|
|
public PlotLayoutSettings plot = new PlotLayoutSettings();
|
|
}
|
|
|
|
public enum RingValueMappingMode
|
|
{
|
|
Percent,
|
|
Range
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class RingValueMappingSettings
|
|
{
|
|
public RingValueMappingMode mode = RingValueMappingMode.Percent;
|
|
public bool autoRange = true;
|
|
public float minValue = 0f;
|
|
public float maxValue = 1f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class RingChartSettings : BaseSerieSettings
|
|
{
|
|
public RingChartLayoutSettings layout = new RingChartLayoutSettings();
|
|
public RingValueMappingSettings valueMapping = new RingValueMappingSettings();
|
|
public PieHoverSettings hover = new PieHoverSettings();
|
|
public PieLegendSettings legend = new PieLegendSettings();
|
|
|
|
public bool showBackground = false;
|
|
public float backgroundAlpha = 0.25f;
|
|
public Color backgroundColor = new Color(0, 0, 0, 0);
|
|
public float cornerRadius = 0f;
|
|
public float ringGapPx = 0f;
|
|
}
|
|
|
|
public enum PieExplodeType
|
|
{
|
|
Translate,
|
|
Pull,
|
|
Color,
|
|
Stroke
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PieHoverSettings
|
|
{
|
|
public bool enabled = false;
|
|
public float explodeDistance = 10f;
|
|
public PieExplodeType explodeType = PieExplodeType.Translate;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PieAggregationSettings
|
|
{
|
|
public bool enabled = false;
|
|
public int keepTopN = 0;
|
|
public string othersName = "Others";
|
|
public bool useOthersColor = false;
|
|
public Color othersColor = new Color(0.6f, 0.6f, 0.6f, 1f);
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class SerieLabelSettings
|
|
{
|
|
public bool enabled = true;
|
|
public Color color = Color.white;
|
|
public int fontSize = 10;
|
|
public int decimalPlaces = 2;
|
|
public bool showName = false; // For Pie: show category name
|
|
public Vector2 offset = Vector2.zero;
|
|
public LabelPosition position = LabelPosition.Outside;
|
|
public TextureFillSettings background = new TextureFillSettings { color = new Color(0f, 0f, 0f, 0f) };
|
|
}
|
|
|
|
public enum LegendPosition
|
|
{
|
|
Top,
|
|
Bottom,
|
|
Left,
|
|
Right
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class LegendSettings : ISerializationCallbackReceiver
|
|
{
|
|
public bool enabled = true;
|
|
public LegendPosition position = LegendPosition.Bottom;
|
|
public int fontSize = 12;
|
|
public Color color = Color.white;
|
|
public Color backgroundColor = new Color(0, 0, 0, 0);
|
|
public float itemSpacing = 10f;
|
|
[Tooltip("Offset from edge. Auto-set based on position when zero.")]
|
|
public Vector2 offset = new Vector2(0, -30);
|
|
|
|
[System.NonSerialized] private LegendPosition _lastPosition = LegendPosition.Bottom;
|
|
[System.NonSerialized] private bool _initialized;
|
|
|
|
public void OnBeforeSerialize() { }
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
if (!_initialized)
|
|
{
|
|
_lastPosition = position;
|
|
_initialized = true;
|
|
}
|
|
}
|
|
|
|
public void SyncOffsetToPosition()
|
|
{
|
|
if (_lastPosition != position)
|
|
{
|
|
offset = GetDefaultOffsetForPosition(position);
|
|
_lastPosition = position;
|
|
}
|
|
}
|
|
|
|
public static Vector2 GetDefaultOffsetForPosition(LegendPosition pos)
|
|
{
|
|
switch (pos)
|
|
{
|
|
case LegendPosition.Top: return new Vector2(0, 30);
|
|
case LegendPosition.Bottom: return new Vector2(0, -30);
|
|
case LegendPosition.Right: return new Vector2(-30, 0);
|
|
case LegendPosition.Left: return new Vector2(30, 0);
|
|
default: return Vector2.zero;
|
|
}
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PlotSettings
|
|
{
|
|
public bool overrideTheme = false;
|
|
public Color backgroundColor = new Color(0f, 0f, 0f, 0f);
|
|
public Color borderColor = new Color(0f, 0f, 0f, 0f);
|
|
public float borderWidth = 0f;
|
|
|
|
[Tooltip("Edge fade distance in pixels for series labels. Labels outside PlotArea will fade to transparent over this distance.")]
|
|
public float labelEdgeFadePx = 20f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class CartesianGridSettings
|
|
{
|
|
public Color xGridColor = new Color(0.5f, 0.5f, 0.5f, 0.2f);
|
|
public float xGridLineWidth = 1.0f;
|
|
public bool xGridDashed = false;
|
|
public float xGridDashLength = 4f;
|
|
public float xGridDashGap = 2f;
|
|
public float xGridDashOffset = 0f;
|
|
public Color yGridColor = new Color(0.5f, 0.5f, 0.5f, 0.2f);
|
|
public float yGridLineWidth = 1.0f;
|
|
public bool yGridDashed = false;
|
|
public float yGridDashLength = 4f;
|
|
public float yGridDashGap = 2f;
|
|
public float yGridDashOffset = 0f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class HoverSettings
|
|
{
|
|
public bool cursorLineDashed = false;
|
|
public float cursorLineWidth = 1f;
|
|
public Color cursorLineColor = Color.yellow;
|
|
public float cursorLineDashLength = 4f;
|
|
public float cursorLineDashGap = 2f;
|
|
public float cursorLineDashOffset = 0f;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PolarAxisStyle
|
|
{
|
|
public List<string> labels = new List<string>();
|
|
|
|
public bool visible = true;
|
|
public Color color = Color.white;
|
|
public Color edgeColor = Color.white;
|
|
public float width = 2.0f;
|
|
|
|
public LabelStyleSettings labelStyle;
|
|
|
|
public bool showLabels = true;
|
|
public int fontSize = 10;
|
|
public Color labelColor = Color.white;
|
|
public LabelPosition labelPosition = LabelPosition.Outside;
|
|
public Vector2 labelOffset = Vector2.zero;
|
|
public bool autoRangeMin = true;
|
|
public bool autoRangeMax = true;
|
|
public AutoRangeRoundingMode autoRangeRounding = AutoRangeRoundingMode.Tens;
|
|
public float autoRangeUnit = 1f;
|
|
public float minValue = 0f;
|
|
public float maxValue = 1f;
|
|
|
|
public bool autoTicks = true;
|
|
public int splitCount = 5;
|
|
public string labelFormat;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class PolarAxesSettings
|
|
{
|
|
public PolarAxisStyle angleAxis = new PolarAxisStyle();
|
|
public PolarAxisStyle radiusAxis = new PolarAxisStyle();
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class ChartData
|
|
{
|
|
public CoordinateSystemType CoordinateSystem = CoordinateSystemType.Cartesian2D;
|
|
public CartesianMapping Cartesian = new CartesianMapping();
|
|
public List<AxisConfig> Axes = new List<AxisConfig>();
|
|
|
|
// New axis fields (X/Y based)
|
|
public AxisId XAxisId = AxisId.XBottom;
|
|
public AxisId YAxisId = AxisId.YLeft;
|
|
|
|
public CartesianGridSettings CartesianGrid = new CartesianGridSettings();
|
|
public HoverSettings Hover = new HoverSettings();
|
|
public PolarAxesSettings PolarAxes = new PolarAxesSettings();
|
|
public PlotSettings Plot = new PlotSettings();
|
|
|
|
public List<Serie> Series = new List<Serie>();
|
|
public LegendSettings legend = new LegendSettings();
|
|
|
|
public float animationDuration = 1.0f;
|
|
}
|
|
|
|
public enum LineType
|
|
{
|
|
Straight,
|
|
Smooth,
|
|
Step
|
|
}
|
|
|
|
public enum LabelPosition
|
|
{
|
|
Outside,
|
|
Inside,
|
|
Center
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class Serie : ISerializationCallbackReceiver
|
|
{
|
|
public string name;
|
|
public string id;
|
|
public SerieType type = SerieType.Line;
|
|
public bool visible = true;
|
|
|
|
[SerializeReference]
|
|
public BaseSerieSettings settings;
|
|
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedLineSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedBarSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedPieSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedRingChartSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedScatterSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedRadarSettings;
|
|
[SerializeField, SerializeReference]
|
|
private BaseSerieSettings _cachedHeatmapSettings;
|
|
|
|
public SerieLabelSettings labelSettings = new SerieLabelSettings();
|
|
|
|
// Actual Data
|
|
public List<SeriesData> seriesData = new List<SeriesData>();
|
|
|
|
public void OnBeforeSerialize()
|
|
{
|
|
}
|
|
|
|
public void OnAfterDeserialize()
|
|
{
|
|
}
|
|
|
|
public bool SetType(SerieType newType)
|
|
{
|
|
bool changed = false;
|
|
|
|
// Preserve current settings into a per-type cache before switching.
|
|
// IMPORTANT: in editor workflows the enum `type` might already be changed
|
|
// (via SerializedObject.ApplyModifiedProperties) before SetType is called,
|
|
// so we cache based on the runtime type of `settings`, not the current `type`.
|
|
if (settings != null)
|
|
{
|
|
if (settings is LineSettings) _cachedLineSettings = settings;
|
|
else if (settings is BarSettings) _cachedBarSettings = settings;
|
|
else if (settings is PieSettings) _cachedPieSettings = settings;
|
|
else if (settings is ScatterSettings) _cachedScatterSettings = settings;
|
|
else if (settings is RadarSettings) _cachedRadarSettings = settings;
|
|
else if (settings is HeatmapSettings) _cachedHeatmapSettings = settings;
|
|
}
|
|
|
|
if (type != newType)
|
|
{
|
|
type = newType;
|
|
changed = true;
|
|
}
|
|
|
|
// Minimal migration / preservation for common edits.
|
|
// Data loss is acceptable per design, but keeping point settings improves UX.
|
|
if (newType == SerieType.Scatter)
|
|
{
|
|
if (settings is ScatterSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedScatterSettings is ScatterSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else if (settings is LineSettings ls)
|
|
{
|
|
if (ls.point == null) ls.point = new PointSettings();
|
|
settings = new ScatterSettings
|
|
{
|
|
point = ls.point,
|
|
sizeMapping = new SizeMappingSettings(),
|
|
hover = new HoverHighlightSettings()
|
|
};
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new ScatterSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.Line)
|
|
{
|
|
if (settings is LineSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedLineSettings is LineSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else if (settings is ScatterSettings ss)
|
|
{
|
|
if (ss.point == null) ss.point = new PointSettings();
|
|
settings = new LineSettings
|
|
{
|
|
point = ss.point,
|
|
stroke = new LineStrokeSettings(),
|
|
area = new AreaFillSettings()
|
|
};
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new LineSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.Bar || newType == SerieType.HorizontalBar)
|
|
{
|
|
if (settings is BarSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedBarSettings is BarSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new BarSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.Pie)
|
|
{
|
|
if (settings is PieSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedPieSettings is PieSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new PieSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.RingChart)
|
|
{
|
|
if (settings is RingChartSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedRingChartSettings is RingChartSettings cachedRing)
|
|
{
|
|
settings = cachedRing;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new RingChartSettings();
|
|
changed = true;
|
|
}
|
|
|
|
if (settings is RingChartSettings ringSettings)
|
|
{
|
|
if (ringSettings.layout == null) { ringSettings.layout = new RingChartLayoutSettings(); changed = true; }
|
|
if (ringSettings.layout != null && ringSettings.layout.innerRadius <= 0f) { ringSettings.layout.innerRadius = 0.3f; changed = true; }
|
|
}
|
|
}
|
|
else if (newType == SerieType.Pie3D)
|
|
{
|
|
if (SerieSettingsRegistry.TryCreate(newType, out var created))
|
|
{
|
|
if (settings is PieSettings oldPs && created is PieSettings newPs && created.GetType() != settings.GetType())
|
|
{
|
|
if (oldPs.layout != null) newPs.layout = oldPs.layout;
|
|
if (oldPs.hover != null) newPs.hover = oldPs.hover;
|
|
if (oldPs.aggregation != null) newPs.aggregation = oldPs.aggregation;
|
|
if (oldPs.ring != null) newPs.ring = oldPs.ring;
|
|
if (oldPs.legend != null) newPs.legend = oldPs.legend;
|
|
settings = newPs;
|
|
changed = true;
|
|
}
|
|
else if (!(settings is PieSettings))
|
|
{
|
|
settings = created;
|
|
changed = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
settings = null;
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.Radar)
|
|
{
|
|
if (settings is RadarSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedRadarSettings is RadarSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new RadarSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (newType == SerieType.Heatmap)
|
|
{
|
|
if (settings is HeatmapSettings)
|
|
{
|
|
// ok
|
|
}
|
|
else if (_cachedHeatmapSettings is HeatmapSettings cached)
|
|
{
|
|
settings = cached;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = new HeatmapSettings();
|
|
changed = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (SerieSettingsRegistry.TryCreate(newType, out var created))
|
|
{
|
|
settings = created;
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
settings = null;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (EnsureIntegrity()) changed = true;
|
|
return changed;
|
|
}
|
|
|
|
public bool EnsureIntegrity()
|
|
{
|
|
bool changed = false;
|
|
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
id = Guid.NewGuid().ToString("N");
|
|
changed = true;
|
|
}
|
|
|
|
var before = settings;
|
|
EnsureSettings();
|
|
if (!ReferenceEquals(before, settings)) changed = true;
|
|
|
|
if (labelSettings == null)
|
|
{
|
|
labelSettings = new SerieLabelSettings();
|
|
changed = true;
|
|
}
|
|
|
|
if (labelSettings != null)
|
|
{
|
|
if (labelSettings.fontSize <= 0)
|
|
{
|
|
labelSettings.fontSize = 10;
|
|
changed = true;
|
|
}
|
|
|
|
if (labelSettings.decimalPlaces < 0 || labelSettings.decimalPlaces > 8)
|
|
{
|
|
labelSettings.decimalPlaces = Mathf.Clamp(labelSettings.decimalPlaces, 0, 8);
|
|
changed = true;
|
|
}
|
|
|
|
var c = labelSettings.color;
|
|
bool looksUninitialized = Mathf.Approximately(c.r, 0f)
|
|
&& Mathf.Approximately(c.g, 0f)
|
|
&& Mathf.Approximately(c.b, 0f)
|
|
&& Mathf.Approximately(c.a, 0f);
|
|
if (looksUninitialized)
|
|
{
|
|
labelSettings.color = Color.white;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (seriesData == null)
|
|
{
|
|
seriesData = new List<SeriesData>();
|
|
changed = true;
|
|
}
|
|
|
|
for (int i = 0; i < seriesData.Count; i++)
|
|
{
|
|
var dp = seriesData[i];
|
|
if (dp == null) continue;
|
|
if (string.IsNullOrEmpty(dp.id))
|
|
{
|
|
dp.id = Guid.NewGuid().ToString("N");
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (settings is LineSettings ls)
|
|
{
|
|
if (ls.stroke == null) { ls.stroke = new LineStrokeSettings(); changed = true; }
|
|
if (ls.point == null) { ls.point = new PointSettings(); changed = true; }
|
|
if (ls.area == null) { ls.area = new AreaFillSettings(); changed = true; }
|
|
}
|
|
else if (settings is ScatterSettings ss)
|
|
{
|
|
if (ss.point == null) { ss.point = new PointSettings(); changed = true; }
|
|
if (ss.sizeMapping == null) { ss.sizeMapping = new SizeMappingSettings(); changed = true; }
|
|
if (ss.hover == null) { ss.hover = new HoverHighlightSettings(); changed = true; }
|
|
}
|
|
else if (settings is BarSettings bs)
|
|
{
|
|
if (bs.border == null) { bs.border = new BorderSettings(); changed = true; }
|
|
if (bs.background == null) { bs.background = new BackgroundSettings(); changed = true; }
|
|
if (bs.hover == null) { bs.hover = new BarHoverSettings(); changed = true; }
|
|
}
|
|
else if (settings is PieSettings ps)
|
|
{
|
|
if (ps.layout == null) { ps.layout = new PieLayoutSettings(); changed = true; }
|
|
if (ps.hover == null) { ps.hover = new PieHoverSettings(); changed = true; }
|
|
if (ps.aggregation == null) { ps.aggregation = new PieAggregationSettings(); changed = true; }
|
|
if (ps.ring == null) { ps.ring = new RingSettings(); changed = true; }
|
|
if (ps.legend == null) { ps.legend = new PieLegendSettings(); changed = true; }
|
|
|
|
if (ps.legend != null
|
|
&& ps.legend.valueDisplayStyle == ValueDisplayStyle.None
|
|
&& ps.legend.showValue)
|
|
{
|
|
ps.legend.valueDisplayStyle = ValueDisplayStyle.Parentheses;
|
|
ps.legend.showValue = false;
|
|
changed = true;
|
|
}
|
|
}
|
|
else if (settings is RadarSettings rs)
|
|
{
|
|
if (rs.radar == null) { rs.radar = new RadarSettings.RadarLayoutSettings(); changed = true; }
|
|
if (rs.radar != null && rs.radar.plot == null) { rs.radar.plot = new PlotLayoutSettings(); changed = true; }
|
|
if (rs.stroke == null) { rs.stroke = new LineStrokeSettings(); changed = true; }
|
|
if (rs.area == null) { rs.area = new AreaFillSettings(); changed = true; }
|
|
if (rs.point == null) { rs.point = new PointSettings(); changed = true; }
|
|
}
|
|
else if (settings is HeatmapSettings hs)
|
|
{
|
|
if (hs.cellGapPx < 0f) { hs.cellGapPx = 0f; changed = true; }
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
public void EnsureSettings()
|
|
{
|
|
bool needCreate = settings == null;
|
|
|
|
if (!needCreate)
|
|
{
|
|
switch (type)
|
|
{
|
|
case SerieType.Line:
|
|
needCreate = !(settings is LineSettings);
|
|
break;
|
|
case SerieType.Scatter:
|
|
needCreate = !(settings is ScatterSettings);
|
|
break;
|
|
case SerieType.Bar:
|
|
case SerieType.HorizontalBar:
|
|
needCreate = !(settings is BarSettings);
|
|
break;
|
|
case SerieType.Pie:
|
|
needCreate = !(settings is PieSettings);
|
|
break;
|
|
case SerieType.RingChart:
|
|
needCreate = !(settings is RingChartSettings);
|
|
break;
|
|
case SerieType.Pie3D:
|
|
if (SerieSettingsRegistry.HasFactory(SerieType.Pie3D))
|
|
{
|
|
if (!(settings is PieSettings))
|
|
{
|
|
needCreate = true;
|
|
}
|
|
else if (SerieSettingsRegistry.TryCreate(SerieType.Pie3D, out var created3D))
|
|
{
|
|
needCreate = created3D != null && created3D.GetType() != settings.GetType();
|
|
}
|
|
else
|
|
{
|
|
needCreate = false;
|
|
}
|
|
}
|
|
else needCreate = false;
|
|
break;
|
|
case SerieType.Radar:
|
|
needCreate = !(settings is RadarSettings);
|
|
break;
|
|
case SerieType.Heatmap:
|
|
needCreate = !(settings is HeatmapSettings);
|
|
break;
|
|
default:
|
|
if (SerieSettingsRegistry.HasFactory(type))
|
|
{
|
|
if (settings == null)
|
|
{
|
|
needCreate = true;
|
|
}
|
|
else if (SerieSettingsRegistry.TryCreate(type, out var createdAny))
|
|
{
|
|
needCreate = createdAny != null && createdAny.GetType() != settings.GetType();
|
|
}
|
|
else
|
|
{
|
|
needCreate = false;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If the type enum changed (or data was migrated) before we got a chance to cache,
|
|
// avoid losing the previous settings instance by stashing it into the matching cache.
|
|
if (needCreate && settings != null)
|
|
{
|
|
if (settings is LineSettings) _cachedLineSettings = settings;
|
|
else if (settings is BarSettings) _cachedBarSettings = settings;
|
|
else if (settings is RingChartSettings) _cachedRingChartSettings = settings;
|
|
else if (settings is PieSettings) _cachedPieSettings = settings;
|
|
else if (settings is ScatterSettings) _cachedScatterSettings = settings;
|
|
else if (settings is RadarSettings) _cachedRadarSettings = settings;
|
|
else if (settings is HeatmapSettings) _cachedHeatmapSettings = settings;
|
|
}
|
|
|
|
if (needCreate)
|
|
{
|
|
switch (type)
|
|
{
|
|
case SerieType.Line:
|
|
settings = _cachedLineSettings is LineSettings cachedLine ? cachedLine : new LineSettings();
|
|
break;
|
|
case SerieType.Scatter:
|
|
settings = _cachedScatterSettings is ScatterSettings cachedScatter ? cachedScatter : new ScatterSettings();
|
|
break;
|
|
case SerieType.Bar:
|
|
case SerieType.HorizontalBar:
|
|
settings = _cachedBarSettings is BarSettings cachedBar ? cachedBar : new BarSettings();
|
|
break;
|
|
case SerieType.Pie:
|
|
settings = _cachedPieSettings is PieSettings cachedPie ? cachedPie : new PieSettings();
|
|
break;
|
|
case SerieType.RingChart:
|
|
settings = _cachedRingChartSettings is RingChartSettings cachedRing ? cachedRing : new RingChartSettings();
|
|
break;
|
|
case SerieType.Pie3D:
|
|
if (SerieSettingsRegistry.TryCreate(type, out var created3D))
|
|
{
|
|
if (created3D is PieSettings createdPie && _cachedPieSettings is PieSettings cachedPieFor3D)
|
|
{
|
|
if (cachedPieFor3D.layout != null) createdPie.layout = cachedPieFor3D.layout;
|
|
if (cachedPieFor3D.hover != null) createdPie.hover = cachedPieFor3D.hover;
|
|
if (cachedPieFor3D.aggregation != null) createdPie.aggregation = cachedPieFor3D.aggregation;
|
|
if (cachedPieFor3D.ring != null) createdPie.ring = cachedPieFor3D.ring;
|
|
}
|
|
settings = created3D;
|
|
}
|
|
else settings = null;
|
|
break;
|
|
case SerieType.Radar:
|
|
settings = _cachedRadarSettings is RadarSettings cachedRadar ? cachedRadar : new RadarSettings();
|
|
break;
|
|
case SerieType.Heatmap:
|
|
settings = _cachedHeatmapSettings is HeatmapSettings cachedHeatmap ? cachedHeatmap : new HeatmapSettings();
|
|
break;
|
|
default:
|
|
if (SerieSettingsRegistry.TryCreate(type, out var createdAny))
|
|
{
|
|
settings = createdAny;
|
|
}
|
|
else
|
|
{
|
|
settings = null;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (type == SerieType.Scatter && settings is ScatterSettings ss)
|
|
{
|
|
if (ss.point == null) ss.point = new PointSettings();
|
|
if (ss.sizeMapping == null) ss.sizeMapping = new SizeMappingSettings();
|
|
if (ss.hover == null) ss.hover = new HoverHighlightSettings();
|
|
}
|
|
|
|
if (type == SerieType.Line && settings is LineSettings ls)
|
|
{
|
|
if (ls.stroke == null) ls.stroke = new LineStrokeSettings();
|
|
if (ls.point == null) ls.point = new PointSettings();
|
|
if (ls.area == null) ls.area = new AreaFillSettings();
|
|
}
|
|
|
|
if (type == SerieType.Bar && settings is BarSettings bs)
|
|
{
|
|
if (bs.border == null) bs.border = new BorderSettings();
|
|
if (bs.background == null) bs.background = new BackgroundSettings();
|
|
}
|
|
|
|
if (type == SerieType.Pie && settings is PieSettings ps)
|
|
{
|
|
if (ps.layout == null) ps.layout = new PieLayoutSettings();
|
|
if (ps.hover == null) ps.hover = new PieHoverSettings();
|
|
if (ps.aggregation == null) ps.aggregation = new PieAggregationSettings();
|
|
if (ps.ring == null) ps.ring = new RingSettings();
|
|
}
|
|
|
|
if (type == SerieType.RingChart && settings is RingChartSettings rcs)
|
|
{
|
|
if (rcs.layout == null) rcs.layout = new RingChartLayoutSettings();
|
|
if (rcs.hover == null) rcs.hover = new PieHoverSettings();
|
|
if (rcs.legend == null) rcs.legend = new PieLegendSettings();
|
|
}
|
|
|
|
if (type == SerieType.Pie3D && settings is PieSettings ps3d)
|
|
{
|
|
if (ps3d.layout == null) ps3d.layout = new PieLayoutSettings();
|
|
if (ps3d.hover == null) ps3d.hover = new PieHoverSettings();
|
|
if (ps3d.aggregation == null) ps3d.aggregation = new PieAggregationSettings();
|
|
if (ps3d.ring == null) ps3d.ring = new RingSettings();
|
|
}
|
|
|
|
if (type == SerieType.Radar && settings is RadarSettings rs)
|
|
{
|
|
if (rs.stroke == null) rs.stroke = new LineStrokeSettings();
|
|
if (rs.point == null) rs.point = new PointSettings();
|
|
}
|
|
|
|
if (type == SerieType.Heatmap && settings is HeatmapSettings hs)
|
|
{
|
|
if (hs.cellGapPx < 0f) hs.cellGapPx = 0f;
|
|
}
|
|
|
|
if (seriesData == null) seriesData = new List<SeriesData>();
|
|
}
|
|
}
|
|
}
|