private int GetPaletteEntryIndex(DataPoint dp)
{
var series = (ChartSeries)dp.Presenter;
var cartesianChart = series.Chart as RadCartesianChart;
var pieChart = series.Chart as RadPieChart;
int index;
if (cartesianChart != null)
{
BarSeries barSeries = series as BarSeries;
BubbleSeries bubbleSeries = series as BubbleSeries;
if ((barSeries != null && barSeries.PaletteMode == SeriesPaletteMode.DataPoint) ||
(bubbleSeries != null && bubbleSeries.PaletteMode == SeriesPaletteMode.DataPoint))
{
index = dp.Index;
}
else
{
index = cartesianChart.Series.IndexOf((CartesianSeries)series);
}
}
else if (pieChart != null)
{
index = pieChart.Series.IndexOf((PieSeries)series);
}
else
{
index = ((RadPolarChart)series.Chart).Series.IndexOf((PolarSeries)series);
}
return(index);
}
public void SetSecurity(string board, string seccode)
{
if (Seccode == seccode)
{
return;
}
TickDataHandler.UnsubscribeFromTicksEvent(TicksToCandles);
TXmlConnector.SendNewCandles -= ProcessCandles;
OhlcDataSeries.Clear();
XyDataSeries.Clear();
StockChartAnnotations = new AnnotationCollection();
Board = board;
Seccode = seccode;
_lastCandle = null;
Task.Run(() => GetHistory());
BubbleSeries.Clear();
GetBubbleData();
var volumes = TickDataHandler.AddChartSubscription(Board, Seccode, TicksToCandles);
HorizontalVolumesBuy = volumes[0];
HorizontalVolumesSell = volumes[1];
UpdateWindowInstrument();
DragStep = Application.Current.Dispatcher
.Invoke(() => MainWindowViewModel.SecVm._secList
.First(s => s.Board == Board && s.Seccode == Seccode).Minstep);
GetOrders();
}
public override View GetSampleContent(Context context)
{
var chart = new SfChart(context);;
chart.SetBackgroundColor(Color.White);
chart.PrimaryAxis = new CategoryAxis {
PlotOffset = 50
};
chart.SecondaryAxis = new NumericalAxis();
var bubble = new BubbleSeries();
bubble.ColorModel.ColorPalette = ChartColorPalette.Metro;
bubble.DataMarker.ShowLabel = true;
bubble.DataMarker.UseSeriesPalette = false;
bubble.DataMarker.LabelStyle.TextColor = Color.White;
var datas = new ObservableArrayList();
datas.Add(new ChartDataPoint("2010", 45, 30));
datas.Add(new ChartDataPoint("2011", 86, 20));
datas.Add(new ChartDataPoint("2012", 23, 15));
datas.Add(new ChartDataPoint("2013", 43, 25));
datas.Add(new ChartDataPoint("2014", 54, 20));
bubble.DataSource = datas;
chart.Series.Add(bubble);
return(chart);
}
public void SizeValueBindingConsistentWithSizeValuePath()
{
BubbleSeries series = DefaultControlToTest as BubbleSeries;
string path = "Path1";
series.SizeValueBinding = new Binding(path);
Assert.IsNotNull(series.SizeValueBinding);
Assert.AreEqual(path, series.SizeValueBinding.Path.Path);
Assert.AreEqual(path, series.SizeValuePath);
series.SizeValueBinding = null;
Assert.IsNull(series.SizeValueBinding);
Assert.IsNull(series.SizeValuePath);
path = "Path2";
series.SizeValuePath = path;
Assert.AreEqual(path, series.SizeValuePath);
Assert.IsNotNull(series.SizeValueBinding);
Assert.AreEqual(path, series.SizeValueBinding.Path.Path);
series.SizeValuePath = null;
Assert.IsNull(series.SizeValuePath);
Assert.IsNull(series.SizeValueBinding);
path = "";
series.SizeValuePath = path;
Assert.AreEqual(path, series.SizeValuePath);
Assert.IsNotNull(series.SizeValueBinding);
Assert.AreEqual(path, series.SizeValueBinding.Path.Path);
}
public override View GetSampleContent(Context context)
{
var chart = new SfChart(context);;
chart.SetBackgroundColor(Color.White);
chart.PrimaryAxis = new CategoryAxis {PlotOffset = 50};
chart.SecondaryAxis = new NumericalAxis();
var bubble = new BubbleSeries();
bubble.ColorModel.ColorPalette = ChartColorPalette.Metro;
bubble.DataMarker.ShowLabel = true;
bubble.DataMarker.UseSeriesPalette = false;
bubble.DataMarker.LabelStyle.TextColor = Color.White;
var datas = new ObservableArrayList();
datas.Add(new ChartDataPoint("2010", 45, 30));
datas.Add(new ChartDataPoint("2011", 86, 20));
datas.Add(new ChartDataPoint("2012", 23, 15));
datas.Add(new ChartDataPoint("2013", 43, 25));
datas.Add(new ChartDataPoint("2014", 54, 20));
bubble.DataSource = datas;
chart.Series.Add(bubble);
return chart;
}
public override void InitialValues()
{
base.InitialValues();
BubbleSeries series = DefaultControlToTest as BubbleSeries;
Assert.IsNull(series.SizeValueBinding);
Assert.IsNull(series.SizeValuePath);
}
public void UsingSizeValuePathWorks()
{
Chart chart = new Chart();
BubbleSeries series = DefaultControlToTest as BubbleSeries;
series.DependentValuePath = "Value";
series.IndependentValuePath = "Key";
series.SizeValuePath = "Value";
series.ItemsSource = new KeyValuePair <int, int>[] { new KeyValuePair <int, int>(1, 2), new KeyValuePair <int, int>(3, 4), new KeyValuePair <int, int>(5, 6) };
chart.Series.Add(series);
TestAsync(
chart,
() => Assert.AreEqual(3, ChartTestUtilities.GetDataPointsForSeries(series).Count()));
}
public override View GetSampleContent(Context context)
{
var chart = new SfChart(context);
chart.Title.Text = "World Countries Details";
chart.Title.TextSize = 15;
NumericalAxis primaryAxis = new NumericalAxis();
primaryAxis.EdgeLabelsDrawingMode = EdgeLabelsDrawingMode.Shift;
primaryAxis.Minimum = 60;
primaryAxis.Maximum = 100;
primaryAxis.Interval = 5;
primaryAxis.Title.Text = "Literacy Rate";
primaryAxis.ShowMajorGridLines = false;
primaryAxis.ShowMinorGridLines = false;
chart.PrimaryAxis = primaryAxis;
NumericalAxis secondaryAxis = new NumericalAxis();
secondaryAxis.Minimum = 0;
secondaryAxis.Maximum = 10;
secondaryAxis.Interval = 2.5;
secondaryAxis.Title.Text = "GDP Growth Rate";
secondaryAxis.ShowMajorGridLines = false;
secondaryAxis.ShowMinorGridLines = false;
chart.SecondaryAxis = secondaryAxis;
var bubble = new BubbleSeries();
bubble.MinimumRadius = 5;
bubble.MaximumRadius = 40;
bubble.Alpha = 0.7f;
bubble.ColorModel.ColorPalette = ChartColorPalette.Natural;
bubble.ItemsSource = MainPage.GetBubbleData();
bubble.XBindingPath = "XValue";
bubble.YBindingPath = "YValue";
bubble.Size = "Size";
bubble.EnableAnimation = true;
chart.Series.Add(bubble);
bubble.TooltipEnabled = true;
tooltipBehavior = new BubbleTooltipBehavior(context);
chart.Behaviors.Add(tooltipBehavior);
chart.TooltipCreated += Chart_TooltipCreated;
return(chart);
}
public MixingTypes()
{
InitializeComponent();
LineSeries = new LineSeries
{
Values = new ChartValues <ObservableValue>
{
new ObservableValue(5),
new ObservableValue(7),
new ObservableValue(2),
new ObservableValue(3),
},
Fill = Brushes.Transparent
};
BubbleSeries = new BubbleSeries
{
Values = new ChartValues <BubblePoint>
{
new BubblePoint(0, 2, 10),
new BubblePoint(1, 1, 2),
new BubblePoint(2, 3, 7),
new BubblePoint(3, 4, 9)
}
};
ColumnSeries = new ColumnSeries
{
Values = new ChartValues <ObservableValue>
{
new ObservableValue(5),
new ObservableValue(7),
new ObservableValue(2),
new ObservableValue(3),
}
};
SeriesCollection = new SeriesCollection
{
LineSeries,
BubbleSeries,
ColumnSeries
};
DataContext = this;
}
private ScatterSplineSeries CopySeries(BubbleSeries series)
{
ScatterSplineSeries trailSeries = new ScatterSplineSeries();
trailSeries.MarkerType = MarkerType.None;
trailSeries.YMemberPath = series.YMemberPath;
trailSeries.XMemberPath = series.XMemberPath;
trailSeries.TransitionDuration = series.TransitionDuration;
trailSeries.Title = series.Title;
trailSeries.XAxis = series.XAxis;
trailSeries.YAxis = series.YAxis;
MotionDataSource <DataPoint> ds = new MotionDataSource <DataPoint>();
trailSeries.ItemsSource = ds;
return(trailSeries);
}
private void InitBubble(List <DaoGuZhiLiangTeXingModel> models)
{
BubbleSeries bubble = new BubbleSeries();
bubble.XAxis = (NumericXAxis)dataChart.Axes[0];
bubble.YAxis = (NumericYAxis)dataChart.Axes[1];
bubble.ItemsSource = models;
bubble.Visibility = Visibility.Visible;
bubble.XMemberPath = "xData";
bubble.YMemberPath = "yData";
bubble.RadiusMemberPath = "rData";
bubble.ToolTip = InitToolTip(models, bubble);
dataChart.Series.Add(bubble);
}
private BubbleSeries GetNewSerie(BubbleData data)
{
Random countRandom = new Random();
ChartYAxisValueCollection <BubbleYAxisValue> yVals = new ChartYAxisValueCollection <BubbleYAxisValue>();
int count = data.XAxisCount;
for (int i = 0; i < count; i++)
{
yVals.Add(new BubbleYAxisValue(countRandom.Next(0, count), countRandom.Next(0, count)));
}
BubbleSeries set1 = new BubbleSeries(yVals, "DataSet 1");
set1.AddColor(DemoGlobal.GetRandomColor());
set1.AddColor(DemoGlobal.GetRandomColor());
set1.AddColor(DemoGlobal.GetRandomColor());
return(set1);
}
private void InitializeSeries(string name, int dataOrder, IEnumerable dataSource = null)
{
BubbleSeries motionSeries = new BubbleSeries();
motionSeries.Name = this.GetSeriesName(dataOrder);
motionSeries.YMemberPath = this.SeriesYMemberPath;
motionSeries.XMemberPath = this.SeriesXMemberPath;
motionSeries.RadiusMemberPath = this.SeriesRadiusMemberPath;
motionSeries.TransitionDuration = this.TransitionDuration;
motionSeries.TransitionEasingFunction = this.TransitionFunction;
motionSeries.Title = name;
motionSeries.XAxis = this.Chart.FindName(XAxisName) as NumericXAxis;
motionSeries.YAxis = this.Chart.FindName(YAxisName) as NumericYAxis;
motionSeries.MarkerTemplate = this.MarkerTemplate;
if (this.ChartLegend != null)
{
motionSeries.Legend = this.ChartLegend;
}
if (this.LegendItemTemplate != null)
{
motionSeries.LegendItemTemplate = this.LegendItemTemplate;
}
// adding the single data point that will be changed in order to be animated over time
List <MotionDataPoint> newDataSource = new List <MotionDataPoint>();
newDataSource.Add(new MotionDataPoint {
ValueX = 0, ValueY = 0, ValueR = 0
});
motionSeries.ItemsSource = newDataSource;
if (dataSource != null)
{
motionSeries.ItemsSource = dataSource;
}
ScatterSplineSeries trailSeries = CopySeries(motionSeries);
trailSeries.Thickness = 2;
motionSeries.Tag = trailSeries;
this.Chart.Series.Add(trailSeries);
this.Chart.Series.Add(motionSeries);
}
private void InitBubble(List <YuMiBaoZiModel> models)
{
BubbleSeries bubble = new BubbleSeries();
bubble.XAxis = (NumericXAxis)dataChart.Axes[0];
bubble.YAxis = (NumericYAxis)dataChart.Axes[1];
bubble.ItemsSource = models;
bubble.Visibility = Visibility.Visible;
bubble.XMemberPath = "xData";
bubble.YMemberPath = "yData";
bubble.RadiusMemberPath = "rData";
bubble.ToolTip = InitToolTip(models, bubble);
//if (dataChart.Series.Count > 0)
//{
// dataChart.Series.Clear();
//}
dataChart.Series.Add(bubble);
}
public BubbleChart()
{
InitializeComponent();
BubbleSeries series = (BubbleSeries)chart.Series[0];
series.ItemsSource =
new KeyValuePair <string, int>[] {
new KeyValuePair <string, int>("男人", 1),
new KeyValuePair <string, int>("女人", 2),
new KeyValuePair <string, int>("外星人", 10),
};
BubbleSeries series2 = chartColumnSeries2;
series2.ItemsSource =
new KeyValuePair <string, int>[] {
new KeyValuePair <string, int>("男人2", 1),
new KeyValuePair <string, int>("女人2", 2),
new KeyValuePair <string, int>("外星人2", 10),
};
}
private void GetBubbleData(object state = null)
{
if (TradeSize == 0)
{
return;
}
var data = TickDataHandler.TickList.First(x => x.Seccode == Seccode).TradeItems.ToList();
data = data.FindAll(t => t.Quantity > TradeSize);
data.Sort((a, b) => a.Time.CompareTo(b.Time));
if (BubbleSeries.Count != 0)
{
var time = BubbleSeries.XValues.Last();
data = data.FindAll(x => DateTime.Parse(x.Time) > time);
}
foreach (var item in data)
{
BubbleSeries.Append(DateTime.Parse(item.Time), item.Price, item.Quantity / 300, new MyMetadata(item.Buysell));
}
}
private static BubbleSeries ProvideBubbleSeries(PropertyInfo propertyInfo, string dependentValuePath,
string independentValuePath)
{
var series = new BubbleSeries();
series.SetBinding(DataPointSeries.ItemsSourceProperty, propertyInfo.GetBinding());
series.IndependentValuePath = independentValuePath;
series.DependentValuePath = dependentValuePath;
series.Unloaded += (o, e) =>
{
var control = o as BubbleSeries;
if (control == null)
{
return;
}
BindingOperations.ClearAllBindings(control);
};
return(series);
}
/// <summary>
/// Draws the path.
/// </summary>
/// <param name="series">The series.</param>
/// <param name="brush">The brush.</param>
/// <param name="strokeThickness">The stroke thickness.</param>
protected override void DrawPath(SeriesBase series, Brush brush, double strokeThickness)
{
if (series is ScatterSeries || series is BubbleSeries)
{
var points = new PointCollection();
var pointCount = 0;
float size = 0;
PartsCollection partsCollection = new PartsCollection();
if (series is ScatterSeries)
{
ScatterSeries scatterSeries = series as ScatterSeries;
points = scatterSeries.ScatterPoints;
pointCount = scatterSeries.ScatterPoints.Count;
size = (float)scatterSeries.ScatterSize;
partsCollection = scatterSeries.Parts;
}
else if (series is BubbleSeries)
{
BubbleSeries scatterSeries = series as BubbleSeries;
points = scatterSeries.BubblePoints;
pointCount = scatterSeries.BubblePoints.Count;
partsCollection = scatterSeries.Parts;
}
if (RenderingMode == RenderingMode.Default)
{
for (int i = 0; i < partsCollection.Count; i++)
{
Ellipse element = (Ellipse)partsCollection[i].CreatePart();
Canvas.SetLeft(element, points[i].X - (element.Width / 2));
Canvas.SetTop(element, points[i].Y - (element.Height / 2));
PartsCanvas.Children.Add(element);
}
}
}
}
private List <Hashtable> SeriesToHashtables(List <Series> listOfSeries)
{
List <Hashtable> hashtableList = new List <Hashtable>();
foreach (Series series in listOfSeries)
{
List <object> dataList = new List <object>();
Hashtable hashtable = new Hashtable();
if (series is LineSeries)
{
LineSeries lineSeries = series as LineSeries;
lineSeries.Data.ForEach(
(Action <LineSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
lineSeries.Type = LineSeriesType.Line;
hashtable = lineSeries.ToHashtable();
}
if (series is SplineSeries)
{
SplineSeries splineSeries = series as SplineSeries;
splineSeries.Data.ForEach((Action <SplineSeriesData>)(data =>
dataList.Add((object)data.ToHashtable())));
splineSeries.Type = SplineSeriesType.Spline;
hashtable = splineSeries.ToHashtable();
}
if (series is AreaSeries)
{
AreaSeries areaSeries = series as AreaSeries;
areaSeries.Data.ForEach(
(Action <AreaSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
areaSeries.Type = AreaSeriesType.Area;
hashtable = areaSeries.ToHashtable();
}
if (series is AreasplineSeries)
{
AreasplineSeries areasplineSeries = series as AreasplineSeries;
areasplineSeries.Data.ForEach(
(Action <AreasplineSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
areasplineSeries.Type = AreasplineSeriesType.Areaspline;
hashtable = areasplineSeries.ToHashtable();
}
if (series is ArearangeSeries)
{
ArearangeSeries arearangeSeries = series as ArearangeSeries;
arearangeSeries.Data.ForEach(
(Action <ArearangeSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
arearangeSeries.Type = ArearangeSeriesType.Arearange;
hashtable = arearangeSeries.ToHashtable();
}
if (series is ColumnrangeSeries)
{
ColumnrangeSeries columnrangeSeries = series as ColumnrangeSeries;
columnrangeSeries.Data.ForEach(
(Action <ColumnrangeSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
columnrangeSeries.Type = ColumnrangeSeriesType.Columnrange;
hashtable = columnrangeSeries.ToHashtable();
}
if (series is BarSeries)
{
BarSeries barSeries = series as BarSeries;
barSeries.Data.ForEach((Action <BarSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
barSeries.Type = BarSeriesType.Bar;
hashtable = barSeries.ToHashtable();
}
if (series is ColumnSeries)
{
ColumnSeries columnSeries = series as ColumnSeries;
columnSeries.Data.ForEach((Action <ColumnSeriesData>)(data =>
dataList.Add((object)data.ToHashtable())));
columnSeries.Type = ColumnSeriesType.Column;
hashtable = columnSeries.ToHashtable();
}
if (series is PieSeries)
{
PieSeries pieSeries = series as PieSeries;
pieSeries.Data.ForEach((Action <PieSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
pieSeries.Type = PieSeriesType.Pie;
hashtable = pieSeries.ToHashtable();
}
if (series is ScatterSeries)
{
ScatterSeries scatterSeries = series as ScatterSeries;
scatterSeries.Data.ForEach(
(Action <ScatterSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
scatterSeries.Type = ScatterSeriesType.Scatter;
hashtable = scatterSeries.ToHashtable();
}
if (series is BubbleSeries)
{
BubbleSeries bubbleSeries = series as BubbleSeries;
bubbleSeries.Data.ForEach((Action <BubbleSeriesData>)(data =>
dataList.Add((object)data.ToHashtable())));
bubbleSeries.Type = BubbleSeriesType.Bubble;
hashtable = bubbleSeries.ToHashtable();
}
if (series is GaugeSeries)
{
GaugeSeries gaugeSeries = series as GaugeSeries;
gaugeSeries.Data.ForEach((Action <GaugeSeriesData>)(data =>
dataList.Add((object)data.ToHashtable())));
gaugeSeries.Type = GaugeSeriesType.Gauge;
hashtable = gaugeSeries.ToHashtable();
}
if (series is SolidgaugeSeries)
{
SolidgaugeSeries solidgaugeSeries = series as SolidgaugeSeries;
solidgaugeSeries.Data.ForEach(
(Action <SolidgaugeSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
solidgaugeSeries.Type = SolidgaugeSeriesType.Solidgauge;
hashtable = solidgaugeSeries.ToHashtable();
}
if (series is HeatmapSeries)
{
HeatmapSeries heatmapSeries = series as HeatmapSeries;
heatmapSeries.Data.ForEach(
(Action <HeatmapSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
heatmapSeries.Type = HeatmapSeriesType.Heatmap;
hashtable = heatmapSeries.ToHashtable();
}
if (series is BoxplotSeries)
{
BoxplotSeries boxplotSeries = series as BoxplotSeries;
boxplotSeries.Data.ForEach(
(Action <BoxplotSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
boxplotSeries.Type = BoxplotSeriesType.Boxplot;
hashtable = boxplotSeries.ToHashtable();
}
if (series is ErrorbarSeries)
{
ErrorbarSeries errorbarSeries = series as ErrorbarSeries;
errorbarSeries.Data.ForEach(
(Action <ErrorbarSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
errorbarSeries.Type = ErrorbarSeriesType.Errorbar;
hashtable = errorbarSeries.ToHashtable();
}
if (series is FunnelSeries)
{
FunnelSeries funnelSeries = series as FunnelSeries;
funnelSeries.Data.ForEach((Action <FunnelSeriesData>)(data =>
dataList.Add((object)data.ToHashtable())));
funnelSeries.Type = FunnelSeriesType.Funnel;
hashtable = funnelSeries.ToHashtable();
}
if (series is PyramidSeries)
{
PyramidSeries pyramidSeries = series as PyramidSeries;
pyramidSeries.Data.ForEach(
(Action <PyramidSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
pyramidSeries.Type = PyramidSeriesType.Pyramid;
hashtable = pyramidSeries.ToHashtable();
}
if (series is WaterfallSeries)
{
WaterfallSeries waterfallSeries = series as WaterfallSeries;
waterfallSeries.Data.ForEach(
(Action <WaterfallSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
waterfallSeries.Type = WaterfallSeriesType.Waterfall;
hashtable = waterfallSeries.ToHashtable();
}
if (series is PolygonSeries)
{
PolygonSeries polygonSeries = series as PolygonSeries;
polygonSeries.Data.ForEach(
(Action <PolygonSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
polygonSeries.Type = PolygonSeriesType.Polygon;
hashtable = polygonSeries.ToHashtable();
}
if (series is TreemapSeries)
{
TreemapSeries treemapSeries = series as TreemapSeries;
treemapSeries.Data.ForEach(
(Action <TreemapSeriesData>)(data => dataList.Add((object)data.ToHashtable())));
treemapSeries.Type = TreemapSeriesType.Treemap;
hashtable = treemapSeries.ToHashtable();
}
hashtableList.Add(hashtable);
}
return(hashtableList);
}
public static ChartsModel.Chart Create()
{
var chart = new ChartsModel.CartesianChart();
chart.Rotated = true;
// Argument Axis
chart.ArgumentAxis = new ChartsModel.Axis()
{
Position = ChartsModel.AxisPosition.Bottom,
GridLinesVisible = false,
GridLinesMinorVisible = false,
TickmarksVisible = false,
Reverse = true,
Visible = true
};
chart.ArgumentAxis.Label = new ChartsModel.AxisLabel(chart.ArgumentAxis)
{
EnableAntialiasing = DefaultBoolean.True,
Visible = true
};
chart.ValueAxis = new ChartsModel.Axis()
{
Position = ChartsModel.AxisPosition.Left,
GridLinesVisible = false,
GridLinesMinorVisible = false,
TickmarksVisible = false,
Visible = false
};
chart.ValueAxis.Label = new ChartsModel.AxisLabel(chart.ArgumentAxis)
{
EnableAntialiasing = DefaultBoolean.True,
Visible = false
};
// Series
var series = new ChartsModel.RangeBarSeries()
{
DisplayName = "Series 1",
LabelsVisibility = false,
BarWidth = 1.0 / (1.0 + 0.25) // 25% gap
};
series.DataMembers[ChartsModel.DataMemberType.Argument] = "Stage";
series.DataMembers[ChartsModel.DataMemberType.Value] = "Min";
series.DataMembers[ChartsModel.DataMemberType.Value2] = "Max";
series.DataMembers[ChartsModel.DataMemberType.Color] = "PointColor";
series.DataSource = FunnelData.GetSampleData();
//series.Appearance = new ChartsModel.SeriesAppearance() { Color = new ChartsModel.ColorARGB(0xff, 0x44, 0x72, 0xc4) };
series.Appearance = new ChartsModel.SeriesAppearance();
series.Appearance.FillStyle = new ChartsModel.FillStyle()
{
FillMode = ChartsModel.FillMode.Solid
};
series.Appearance.Color = new ChartsModel.ColorARGB(0xff, 0xff, 0, 0);
//Data Labels
// UNCOMMENT for InvalidCastException under WinForms
//series.Label = new ChartsModel.SeriesLabel(series) {
// EnableAntialiasing = DefaultBoolean.True,
// Position = ChartsModel.SeriesLabelPosition.InsideBase,
//};
series.Appearance.LabelAppearance = new ChartsModel.SeriesLabelAppearance()
{
LineVisible = false,
Border = new ChartsModel.Border()
{
Color = ChartsModel.ColorARGB.Transparent
},
TextColor = new ChartsModel.ColorARGB(0xff, 0xff, 0xff, 0xff),
BackColor = ChartsModel.ColorARGB.Transparent
};
if (series is ChartsModel.ISupportTransparencySeries seriesWithTransparency)
{
seriesWithTransparency.Transparency = 0;
}
chart.Series.Add(series);
var pointSeries = new BubbleSeries()
{
DisplayName = "Series 2",
LabelsVisibility = true,
};
pointSeries.DataMembers[ChartsModel.DataMemberType.Argument] = "Stage";
pointSeries.DataMembers[ChartsModel.DataMemberType.Value] = "Mid";
pointSeries.DataMembers[ChartsModel.DataMemberType.Weight] = "Mid";
pointSeries.DataSource = FunnelData.GetSampleData();
pointSeries.Appearance = new ChartsModel.SeriesAppearance();
pointSeries.Appearance.Color = ChartsModel.ColorARGB.Transparent;
pointSeries.Appearance.FillStyle = new ChartsModel.FillStyle()
{
FillMode = ChartsModel.FillMode.Empty
};
pointSeries.Appearance.Border = new ChartsModel.Border()
{
Color = ChartsModel.ColorARGB.Transparent
};
pointSeries.Appearance.MarkerAppearance = new MarkerAppearance()
{
BorderVisible = false,
BorderColor = ChartsModel.ColorARGB.Transparent,
FillStyle = new FillStyle()
{
FillMode = ChartsModel.FillMode.Empty
}
};
pointSeries.ShowInLegend = false;
pointSeries.Label = new ChartsModel.SeriesLabel(series)
{
EnableAntialiasing = DefaultBoolean.True,
Position = ChartsModel.SeriesLabelPosition.Center,
Formatter = new FunnelFormatter()
};
pointSeries.Appearance.LabelAppearance = new ChartsModel.SeriesLabelAppearance()
{
LineVisible = false,
Border = new ChartsModel.Border()
{
Color = ChartsModel.ColorARGB.Transparent
},
TextColor = new ChartsModel.ColorARGB(0xff, 0xff, 0xff, 0xff),
BackColor = ChartsModel.ColorARGB.Transparent
};
chart.Series.Add(pointSeries);
// Legend
var legend = new ChartsModel.Legend {
EnableAntialiasing = DefaultBoolean.True,
LegendPosition = ChartsModel.LegendPosition.Top,
Orientation = ChartsModel.LegendOrientation.Horizontal,
Overlay = false
};
chart.Legend = legend;
// Title
var title = new ChartsModel.ChartTitle {
EnableAntialiasing = DefaultBoolean.True,
Lines = new string[] { "Sales Pipeline" }
};
chart.Titles.Add(title);
ChartAppearanceHelper.SetupAppearance(chart);
chart.Appearance.DiagramAppearance.BorderVisible = false;
return(chart);
//var chart = new ChartsModel.FunnelChart();
//// Argument Axis
////chart.ArgumentAxis = new ChartsModel.Axis() {
//// Position = ChartsModel.AxisPosition.Bottom,
//// GridLinesVisible = false,
//// GridLinesMinorVisible = false,
//// TickmarksVisible = false,
//// Visible = true
////};
////chart.ArgumentAxis.Label = new ChartsModel.AxisLabel(chart.ArgumentAxis) {
//// EnableAntialiasing = DefaultBoolean.True,
//// Visible = true
////};
//// Series
//var series = new ChartsModel.FunnelSeries() {
// DisplayName = "Series 1",
// LabelsVisibility = true,
// PointShape = ChartsModel.FunnelPointShape.Rectangle
//};
//series.DataMembers[ChartsModel.DataMemberType.Argument] = "Stage";
//series.DataMembers[ChartsModel.DataMemberType.Value] = "Amount";
//series.DataMembers[ChartsModel.DataMemberType.Color] = "PointColor";
//series.DataSource = FunnelData.GetSampleData();
////series.Appearance = new ChartsModel.SeriesAppearance() { Color = new ChartsModel.ColorARGB(0xff, 0x44, 0x72, 0xc4) };
//series.Appearance = new ChartsModel.SeriesAppearance();
//series.Appearance.FillStyle = new ChartsModel.FillStyle() { FillMode = ChartsModel.FillMode.Solid };
//series.Appearance.Color = new ChartsModel.ColorARGB(0xff, 0xff, 0, 0);
////Data Labels
//series.Label = new ChartsModel.SeriesLabel(series) {
// EnableAntialiasing = DefaultBoolean.True,
// Position = ChartsModel.SeriesLabelPosition.Center
//};
//series.Appearance.LabelAppearance = new ChartsModel.SeriesLabelAppearance() {
// LineVisible = false,
// Border = new ChartsModel.Border() { Color = ChartsModel.ColorARGB.Transparent },
// TextColor = new ChartsModel.ColorARGB(0xff, 0xff, 0xff, 0xff),
// BackColor = ChartsModel.ColorARGB.Transparent
//};
//if (series is ChartsModel.ISupportTransparencySeries seriesWithTransparency)
// seriesWithTransparency.Transparency = 0;
//chart.Series.Add(series);
//// Legend
//var legend = new ChartsModel.Legend {
// EnableAntialiasing = DefaultBoolean.True,
// LegendPosition = ChartsModel.LegendPosition.Top,
// Orientation = ChartsModel.LegendOrientation.Horizontal,
// Overlay = false
//};
//chart.Legend = legend;
//// Title
//var title = new ChartsModel.ChartTitle {
// EnableAntialiasing = DefaultBoolean.True,
// Lines = new string[] { "Sales Pipeline" }
//};
//chart.Titles.Add(title);
//ChartAppearanceHelper.SetupAppearance(chart);
//return chart;
}
override protected void DrawPath(SeriesBase series, System.Drawing.Pen pen)
{
if (series is ScatterSeries || series is BubbleSeries)
{
var points = new PointCollection();
var sizes = new List <double>();
var pointCount = 0;
float size = 0;
var brush = new SolidColorBrush(Colors.Blue).AsDrawingBrush();
PartsCollection partsCollection = new PartsCollection();
if (series is ScatterSeries)
{
ScatterSeries scatterSeries = series as ScatterSeries;
points = scatterSeries.ScatterPoints;
pointCount = scatterSeries.ScatterPoints.Count;
size = (float)scatterSeries.ScatterSize;
brush = (this.Series as ScatterSeries).Fill.AsDrawingBrush();
partsCollection = scatterSeries.Parts;
}
else if (series is BubbleSeries)
{
BubbleSeries scatterSeries = series as BubbleSeries;
points = scatterSeries.BubblePoints;
pointCount = scatterSeries.BubblePoints.Count;
//size = (float)scatterSeries.;
sizes = scatterSeries.SizeValues;
brush = (this.Series as FillSeriesBase).Fill.AsDrawingBrush();
partsCollection = scatterSeries.Parts;
}
if (RenderingMode == RenderingMode.Default)
{
for (int i = 0; i < partsCollection.Count; i++)
{
Ellipse element = (Ellipse)partsCollection[i].CreatePart();
if (element != null && !PartsCanvas.Children.Contains(element))
{
PartsCanvas.Children.Add(element);
}
}
}
else
{
for (int i = 0; i < pointCount; i++)
{
if (series is ScatterSeries)
{
switch (RenderingMode)
{
case RenderingMode.GDIRendering:
GDIGraphics.DrawEllipse(pen, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
GDIGraphics.FillEllipse(brush, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
break;
case RenderingMode.Default:
break;
case RenderingMode.WritableBitmap:
this.WritableBitmap.Lock();
WritableBitmapGraphics.DrawEllipse(pen, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
WritableBitmapGraphics.FillEllipse(brush, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
this.WritableBitmap.Unlock();
break;
default:
break;
}
}
else
{
size = (int)sizes[i];
switch (RenderingMode)
{
case RenderingMode.GDIRendering:
GDIGraphics.DrawEllipse(pen, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
GDIGraphics.FillEllipse(brush, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
break;
case RenderingMode.Default:
break;
case RenderingMode.WritableBitmap:
this.WritableBitmap.Lock();
WritableBitmapGraphics.DrawEllipse(pen, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
WritableBitmapGraphics.FillEllipse(brush, points[i].AsDrawingPointF().X - size / 2, points[i].AsDrawingPointF().Y - size / 2, size, size);
this.WritableBitmap.Unlock();
break;
default:
break;
}
}
}
this.Collection.InvalidateBitmap();
}
}
}
bool ProcessSeriesData(ref List <object> listOfSeries, string chartType, string seriesDataString, ref string failOverMessage)
{
bool parsed = false;
bool isSingleSeries = false;
List <ColumnSeries> columnSeriesList = new List <ColumnSeries>();
string[] seriesDataStringArray = seriesDataString.Split(new string[] { Statics.SeparateLineSeries }, StringSplitOptions.RemoveEmptyEntries);
if (seriesDataStringArray.Length < 1)
{
isSingleSeries = true;
}
foreach (string lineSeriesItemString in seriesDataStringArray)
{
object series;
switch (chartType.ToUpper().Replace(" ", ""))
{
case Statics.Area:
series = new AreaSeries();
((AreaSeries)series).IndependentValuePath = "Key";
((AreaSeries)series).DependentValuePath = "Value";
break;
case Statics.Bar:
series = new ColumnSeries();
((ColumnSeries)series).IndependentValuePath = "Key";
((ColumnSeries)series).DependentValuePath = "Value";
break;
case Statics.Bubble:
series = new BubbleSeries();
((BubbleSeries)series).IndependentValuePath = "Key";
((BubbleSeries)series).DependentValuePath = "Value";
break;
case Statics.RotatedBar:
series = new BarSeries();
((BarSeries)series).IndependentValuePath = "Key";
((BarSeries)series).DependentValuePath = "Value";
break;
case Statics.Histogram:
series = new ColumnSeries();
((ColumnSeries)series).IndependentValuePath = "Key";
((ColumnSeries)series).DependentValuePath = "Value";
break;
case Statics.Line:
series = new LineSeries();
((LineSeries)series).IndependentValuePath = "Key";
((LineSeries)series).DependentValuePath = "Value";
break;
case Statics.Pie:
series = new PieSeries();
((PieSeries)series).IndependentValuePath = "Key";
((PieSeries)series).DependentValuePath = "Value";
break;
case Statics.Scatter:
series = new ScatterSeries();
((ScatterSeries)series).IndependentValuePath = "Key";
((ScatterSeries)series).DependentValuePath = "Value";
break;
case Statics.Stacked:
//series = new StackedBarSeries();
//((StackedBarSeries)series).IndependentValuePath = "Key";
//((StackedBarSeries)series).DependentValuePath = "Value";
case Statics.TreeMap:
default:
failOverMessage = "The specified graph type supplied in the input parameters (initParams) could not be parsed.";
return(false);
}
string[] titleSplit = lineSeriesItemString.Split(new string[] { Statics.LineSeriesTitle }, StringSplitOptions.None);
if (titleSplit.Length == 3)
{
switch (chartType.ToUpper().Replace(" ", ""))
{
case Statics.Area:
((AreaSeries)series).Title = titleSplit[1];
break;
case Statics.Bar:
((ColumnSeries)series).Title = titleSplit[1];
break;
case Statics.Bubble:
((BubbleSeries)series).Title = titleSplit[1];
break;
case Statics.RotatedBar:
((BarSeries)series).Title = titleSplit[1];
break;
case Statics.Histogram:
((ColumnSeries)series).Title = titleSplit[1];
break;
case Statics.Line:
((LineSeries)series).Title = titleSplit[1];
break;
case Statics.Pie:
((PieSeries)series).Title = titleSplit[1];
break;
case Statics.Scatter:
((ScatterSeries)series).Title = titleSplit[1];
break;
case Statics.Stacked:
case Statics.TreeMap:
default:
break;
}
}
Dictionary <object, object> pointList = new Dictionary <object, object>();
string[] dataSplit = lineSeriesItemString.Split(new string[] { Statics.LineSeriesDataString }, StringSplitOptions.None);
object independentValue = string.Empty;
object dependentValue = 0.0;
if (dataSplit.Length == 3)
{
string dataString = dataSplit[1];
string[] dataPairStringArray = dataString.Split(new string[] { Statics.SeparateDataPoints }, StringSplitOptions.None);
foreach (string pair in dataPairStringArray)
{
if (pair.Length > 0)
{
string[] set = pair.Split(new string[] { Statics.SeparateIndDepValues }, StringSplitOptions.None);
try
{
if (set.Length == 2)
{
Double doubleCandidate;
DateTime dateTimeCandidate;
// < independent >
if (Double.TryParse(set[0], out doubleCandidate))
{
independentValue = doubleCandidate;
if (_minIndependentValueIsValid)
{
if ((double)independentValue < (double)_minIndependentValue)
{
_minIndependentValue = independentValue;
}
}
else
{
_minIndependentValue = independentValue;
_minIndependentValueIsValid = true;
}
if (_maxIndependentValueIsValid)
{
if ((double)independentValue > (double)_maxIndependentValue)
{
_maxIndependentValue = independentValue;
}
}
else
{
_maxIndependentValue = independentValue;
_maxIndependentValueIsValid = true;
}
}
else if (DateTime.TryParse(set[0], out dateTimeCandidate))
{
independentValue = dateTimeCandidate;
if (_minIndependentValueIsValid)
{
if ((DateTime)independentValue < (DateTime)_minIndependentValue)
{
_minIndependentValue = independentValue;
}
}
else
{
_minIndependentValue = independentValue;
_minIndependentValueIsValid = true;
}
if (_maxIndependentValueIsValid)
{
if ((DateTime)independentValue > (DateTime)_maxIndependentValue)
{
_maxIndependentValue = independentValue;
}
}
else
{
_maxIndependentValue = independentValue;
_maxIndependentValueIsValid = true;
}
}
else
{
independentValue = set[0].ToString();
}
// < dependent >
if (Double.TryParse(set[1], out doubleCandidate))
{
dependentValue = doubleCandidate;
}
else if (DateTime.TryParse(set[1], out dateTimeCandidate))
{
dependentValue = dateTimeCandidate;
}
else
{
dependentValue = set[1].ToString();
}
pointList.Add(independentValue, dependentValue);
}
}
catch
{
return(false);
}
}
}
}
else
{
failOverMessage = string.Format("Parse fail with '{0}'", lineSeriesItemString);
return(false);
}
AddItemSourceToSeries(chartType, series, pointList);
if (isSingleSeries)
{
AddAxesToSeries(chartType, series, independentValue);
}
else
{
//((ColumnSeries)series).IndependentAxis = new LinearAxis
//{
// Title = _independentLabel,
// Orientation = AxisOrientation.X,
// Minimum = (double)_minIndependentValue,
// Maximum = (double)_maxIndependentValue
//};
}
listOfSeries.Add(series);
parsed = true;
}
return(parsed);
}
