/// <summary> /// Core element processing. /// The <see cref="RectangleGeometry"/> inside the <see cref="Path"/> is now location-invariant wrt x-axis. /// This means that during incremental updates, no re-calculation is required, only adjusting the <see cref="Canvas.LeftProperty"/>. /// </summary> /// <param name="index">Data index.</param> /// <param name="valuec1">C1 (x-axis) index.</param> /// <param name="valuec2">C2 (y-axis) index.</param> /// <param name="value">Cell value.</param> /// <param name="item"></param> /// <param name="recycler"></param> /// <param name="byl"></param> /// <returns></returns> ItemState <Path> ElementPipeline(int index, int valuec1, int valuec2, double value, object item, Recycler <Path, ItemState <Path> > recycler, BindingEvaluator byl) { var path = recycler.Next(null); if (path == null) { return(null); } var shim = new GeometryWith2OffsetShim <RectangleGeometry>() { // MUST use invariant geometry here so it can translate. PathData = new RectangleGeometry() { Rect = new Rect(new Point(0, 0), new Point(1, 1)) } }; path.Item2.DataContext = shim; // connect the shim to template root element's Visibility BindTo(shim, nameof(shim.Visibility), path.Item2, UIElement.VisibilityProperty); BindTo(shim, nameof(shim.Offset), path.Item2, Canvas.LeftProperty); BindTo(shim, nameof(shim.Offset2), path.Item2, Canvas.TopProperty); if (byl == null) { return(new SeriesItemState_Double(index, valuec1, 0, valuec2, value, path.Item2)); } else { var cs = byl.For(item); return(new SeriesItemState_Custom(index, valuec1, 0, valuec2, value, cs, path.Item2)); } }
ItemState CreateSubtick(IChartRenderContext icrc, Recycler <Path, ItemState> recycler, SubtickState tick) { if (tick.Value <= ValueAxis.Minimum || tick.Value >= ValueAxis.Maximum) { return(null); } var state = new ItemState() { Tick = tick }; var current = recycler.Next(state); if (!current.Item1) { // restore binding if (MinorGridPathStyle != null) { BindTo(this, nameof(MinorGridPathStyle), current.Item2, FrameworkElement.StyleProperty); TransferFromStyle(current.Item2, MinorGridPathStyle); } else if (PathStyle != null) { BindTo(this, nameof(PathStyle), current.Item2, FrameworkElement.StyleProperty); TransferFromStyle(current.Item2, PathStyle); } } state.Element = current.Item2; ApplyBinding(this, nameof(Visibility), state.Element, UIElement.VisibilityProperty); state.SetLocation(icrc.Area.Left, tick.Value); return(state); }
/// <summary> /// Core element creation. /// </summary> /// <param name="index"></param> /// <param name="valuex"></param> /// <param name="valuey"></param> /// <param name="item"></param> /// <param name="recycler"></param> /// <param name="evs"></param> /// <returns></returns> ItemState <Path> ElementPipeline(int index, double valuex, double valuey, object item, Recycler <Path, ItemState <Path> > recycler, Evaluators evs) { var mappedy = ValueAxis.For(valuey); var mappedx = CategoryAxis.For(valuex); var markerx = mappedx + MarkerOffset; _trace.Verbose($"[{index}] {valuey} ({markerx},{mappedy})"); var mk = MarkerTemplate.LoadContent() as Geometry; // TODO allow MK to be other things like (Path or Image). // TODO allow a MarkerTemplateSelector and a value Selector/Formatter // no path yet var el = recycler.Next(null); if (el == null) { return(null); } var shim = new GeometryWithOffsetShim <Geometry>() { PathData = mk }; el.Item2.DataContext = shim; BindTo(shim, nameof(shim.Offset), el.Item2, Canvas.LeftProperty); var cs = evs.LabelFor(item); if (cs == null) { return(new ItemState_Matrix <Path>(index, mappedx, MarkerOffset, mappedy, el.Item2)); } else { return(new ItemStateCustom_Matrix <Path>(index, mappedx, MarkerOffset, mappedy, cs, el.Item2)); } }
/// <summary> /// Core element creation. /// </summary> /// <param name="index"></param> /// <param name="valuex"></param> /// <param name="valuey"></param> /// <param name="item"></param> /// <param name="recycler"></param> /// <param name="evs"></param> /// <returns></returns> ItemState <Image> ElementPipeline(int index, double valuex, double valuey, object item, Recycler <Image, ItemState <Image> > recycler, Evaluators evs) { var mappedy = ValueAxis.For(valuey); var mappedx = CategoryAxis.For(valuex); var markerx = mappedx + MarkerOffset; _trace.Verbose($"[{index}] {valuey} ({markerx},{mappedy})"); // TODO allow a MarkerTemplateSelector and a value Selector/Formatter // no path yet var el = recycler.Next(null); if (el == null) { return(null); } var cs = evs.LabelFor(item); if (cs == null) { return(new ItemState_Matrix <Image>(index, mappedx, MarkerOffset, mappedy, el.Item2)); } else { return(new ItemStateCustom_Matrix <Image>(index, mappedx, MarkerOffset, mappedy, cs, el.Item2)); } }
/// <summary> /// Create the next series state. /// </summary> /// <param name="index"></param> /// <param name="valuex"></param> /// <param name="item"></param> /// <param name="recycler"></param> /// <param name="evs"></param> /// <returns>New instance or NULL.</returns> SeriesItemState ElementPipeline(int index, double valuex, object item, Recycler <Path, SeriesItemState> recycler, Evaluators evs) { var leftx = CategoryAxis.For(valuex); var barx = BarOffset; var rightx = barx + BarWidth; var sis = evs.byl == null ? new SeriesItemState(index, leftx, BarOffset) : new SeriesItemState_Custom(index, leftx, BarOffset, evs.byl.For(item)); for (int ix = 0; ix < evs.bys.Length; ix++) { var valuey = CoerceValue(item, evs.bys[ix]); if (double.IsNaN(valuey)) { continue; } var colbase = valuey >= 0 ? sis.Max : sis.Min; var colend = colbase + valuey; var y1 = ValueAxis.For(colend); var y2 = ValueAxis.For(colbase); var topy = Math.Max(y1, y2); var bottomy = Math.Min(y1, y2); sis.UpdateLimits(y1); _trace.Verbose($"{Name}[{index},{ix}] {valuey} ({barx},{topy}) ({rightx},{bottomy}) sis ({sis.Min},{sis.Max})"); var path = recycler.Next(null); if (path == null) { return(null); } var shim = new GeometryWithOffsetShim <RectangleGeometry>() { PathData = new RectangleGeometry() { Rect = new Rect(new Point(barx, topy), new Point(rightx, bottomy)) } }; path.Item2.DataContext = shim; BindTo(ColumnStack[ix], "PathStyle", path.Item2, FrameworkElement.StyleProperty); // bind offset BindTo(shim, nameof(shim.Offset), path.Item2, Canvas.LeftProperty); UpdateLimits(valuex, sis.Min, sis.Max); sis.Elements.Add(new Tuple <double, Path>(valuey, path.Item2)); } return(sis); }
/// <summary> /// Core element processing. /// The <see cref="RectangleGeometry"/> inside the <see cref="Path"/> is now location-invariant wrt x-axis. /// This means that during incremental updates, no re-calculation is required, only adjusting the <see cref="Canvas.LeftProperty"/>. /// </summary> /// <param name="index"></param> /// <param name="valuex"></param> /// <param name="valuey"></param> /// <param name="item"></param> /// <param name="recycler"></param> /// <param name="byl"></param> /// <returns></returns> ItemState <Path> ElementPipeline(int index, double valuex, double valuey, object item, Recycler <Path, ItemState <Path> > recycler, BindingEvaluator byl) { var y1 = ValueAxis.For(valuey); var y2 = ValueAxis.For(0); var topy = Math.Max(y1, y2); var bottomy = Math.Min(y1, y2); var leftx = CategoryAxis.For(valuex); var barx = BarOffset; var rightx = barx + BarWidth; _trace.Verbose($"{Name}[{index}] {valuey} ({barx},{topy}) ({rightx},{bottomy})"); var path = recycler.Next(null); if (path == null) { return(null); } var shim = new GeometryWithOffsetShim <RectangleGeometry>() { PathData = new RectangleGeometry() { Rect = new Rect(new Point(barx, topy), new Point(rightx, bottomy)) } }; path.Item2.DataContext = shim; // connect the shim to template root element's Visibility BindTo(shim, nameof(shim.Visibility), path.Item2, UIElement.VisibilityProperty); BindTo(shim, nameof(shim.Offset), path.Item2, Canvas.LeftProperty); if (byl == null) { return(new SeriesItemState_Double(index, leftx, BarOffset, y1, path.Item2)); } else { var cs = byl.For(item); return(new SeriesItemState_Custom(index, leftx, BarOffset, y1, cs, path.Item2)); } }
/// <summary> /// Main flow of the render pipeline. /// </summary> /// <param name="sc"></param> /// <param name="ist"></param> /// <param name="recycler"></param> void ElementPipeline(SelectorContext sc, ItemState ist, Recycler <FrameworkElement, ItemState> recycler) { sc.SetTick(ist.index); var createit = true; if (LabelSelector != null) { var ox = LabelSelector.Convert(sc, typeof(bool), null, System.Globalization.CultureInfo.CurrentUICulture.Name); if (ox is bool bx) { createit = bx; } else { createit = ox != null; } } if (!createit) { return; } var current = recycler.Next(ist); if (current == null) { return; } if (!current.Item1) { // recycled: restore binding if we are using a LabelFormatter if (LabelFormatter != null && LabelStyle != null) { BindTo(this, nameof(LabelStyle), current.Item2, FrameworkElement.StyleProperty); } } // default text var text = ist.label == null ? String.Empty : (String.IsNullOrEmpty(LabelFormatString) ? ist.label.ToString() : String.Format(LabelFormatString, ist.label) ); if (LabelFormatter != null) { // call for Style, String override var format = LabelFormatter.Convert(sc, typeof(Tuple <Style, String>), null, System.Globalization.CultureInfo.CurrentUICulture.Name); if (format is Tuple <Style, String> ovx) { if (ovx.Item1 != null) { current.Item2.Style = ovx.Item1; } if (ovx.Item2 != null) { text = ovx.Item2; } } } // back-fill values var shim = new TextShim() { Text = text }; current.Item2.DataContext = shim; BindTo(shim, nameof(Visibility), current.Item2, UIElement.VisibilityProperty); ist.element = current.Item2; sc.Generated(ist); }
/// <summary> /// Get the next element from the recycler. /// </summary> /// <param name="state"></param> /// <returns></returns> internal Tuple <bool, EL> Next(SIS state) { return(recycler.Next(state)); }
ItemState <Path> ElementPipeline( int index, double valuex, double valueO, double valueH, double valueL, double valueC, object item, Recycler <Path, ItemState <Path> > recycler, BindingEvaluator bvl ) { // map through axes var y1 = ValueAxis.For(valueO); var y2 = ValueAxis.For(valueC); var y3 = ValueAxis.For(valueH); var y4 = ValueAxis.For(valueL); var leftx = CategoryAxis.For(valuex); var offsetx = BarOffset; var rightx = offsetx + BarWidth; // force them to be a min/max var topy = Math.Max(y1, y2); var bottomy = Math.Min(y1, y2); var highy = Math.Max(y3, y4); var lowy = Math.Min(y3, y4); _trace.Verbose($"{Name}[{index}] {valueO}/{valueH}/{valueL}/{valueC} ({offsetx},{topy}) ({rightx},{bottomy})"); // create geometry var path = recycler.Next(null); if (path == null) { return(null); } var pg = new PathGeometry(); // body (open/close) var body = PathHelper.Rectangle(offsetx, topy, rightx, bottomy); pg.Figures.Add(body); // upper shadow (high) var centerx = offsetx + (rightx - offsetx) / 2; var upper = PathHelper.Line(centerx, topy, centerx, highy); pg.Figures.Add(upper); // lower shadow (low) var lower = PathHelper.Line(centerx, bottomy, centerx, lowy); pg.Figures.Add(lower); var shim = new GeometryWithOffsetShim <PathGeometry>() { PathData = pg }; path.Item2.DataContext = shim; // establish the style for "forward" or "reverse" polarity BindTo(this, valueO < valueC ? nameof(PathStyle) : nameof(ReversePathStyle), path.Item2, Path.StyleProperty); // bind offset BindTo(shim, nameof(shim.Offset), path.Item2, Canvas.LeftProperty); var figs = new Tuple <double, PathFigure> [4]; figs[0] = new Tuple <double, PathFigure>(y1, body); figs[1] = new Tuple <double, PathFigure>(y2, body); figs[2] = new Tuple <double, PathFigure>(y3, upper); figs[3] = new Tuple <double, PathFigure>(y4, lower); if (bvl == null) { return(new SeriesItemState(index, leftx, BarOffset, y1, path.Item2, figs)); } else { var cs = bvl.For(item); return(new SeriesItemState_Custom(index, leftx, BarOffset, y1, cs, path.Item2, figs)); } }
/// <summary> /// Grid coordinates: /// x: "normalized" [0..1] and scaled to the area-width /// y: "axis" scale /// </summary> /// <param name="icrc"></param> void IRequireRender.Render(IChartRenderContext icrc) { if (ValueAxis == null) { return; } if (double.IsNaN(ValueAxis.Maximum) || double.IsNaN(ValueAxis.Minimum)) { return; } // grid lines var tc = new TickCalculator(ValueAxis.Minimum, ValueAxis.Maximum); var recycler = new Recycler <Path, ItemState>(GridLines.Where(tl => tl.Element != null).Select(tl => tl.Element), (ist) => { return(CreateElement(ist)); }); var mrecycler = new Recycler <Path, ItemState>(MinorGridLines.Where(tl => tl.Element != null).Select(tl => tl.Element), (ist) => { return(CreateSubElement(ist)); }); var itemstate = new List <ItemState>(); var mitemstate = new List <ItemState>(); //_trace.Verbose($"grid range:{tc.Range} tintv:{tc.TickInterval}"); var tixarray = tc.GetTicks().ToArray(); var sc = new ValueAxisSelectorContext(ValueAxis, icrc.SeriesArea, tixarray, tc.TickInterval); for (int ix = 0; ix < tixarray.Length; ix++) { var tick = tixarray[ix]; //_trace.Verbose($"grid vx:{tick}"); var state = new ItemState() { Tick = tick }; var current = recycler.Next(state); if (!current.Item1) { // restore binding if (PathStyle != null) { BindTo(this, nameof(PathStyle), current.Item2, FrameworkElement.StyleProperty); } } state.Element = current.Item2; ApplyBinding(this, nameof(Visibility), state.Element, UIElement.VisibilityProperty); if (PathFormatter != null) { sc.SetTick(ix); // call for Style, String override var format = PathFormatter.Convert(sc, typeof(Tuple <Style, String>), null, System.Globalization.CultureInfo.CurrentUICulture.Name); if (format is Tuple <Style, String> ovx) { if (ovx.Item1 != null) { current.Item2.Style = ovx.Item1; } } } state.SetLocation(icrc.Area.Left, tick.Value); sc.Generated(tick); itemstate.Add(state); if (MinorGridLineCount != 0) { // lay out minor divisions var mintv = tc.TickInterval / (double)(MinorGridLineCount + 1); var diry = Math.Sign(tick.Index); if (diry == 0) { // special case: zero for (int mx = 1; mx <= MinorGridLineCount; mx++) { var mtick = new SubtickState(tick.Index, mx, tick.Value + (double)mx * mintv); var mstate = CreateSubtick(icrc, mrecycler, mtick); if (mstate != null) { mitemstate.Add(mstate); } var mtick2 = new SubtickState(tick.Index, -mx, tick.Value + (double)(-mx) * mintv); var mstate2 = CreateSubtick(icrc, mrecycler, mtick2); if (mstate2 != null) { mitemstate.Add(mstate2); } } } else { for (int mx = 1; mx <= MinorGridLineCount; mx++) { var mtick = new SubtickState(tick.Index, diry * mx, tick.Value + (double)(diry * mx) * mintv); var mstate = CreateSubtick(icrc, mrecycler, mtick); if (mstate != null) { mitemstate.Add(mstate); } } } } } // VT and internal bookkeeping MinorGridLines = mitemstate; GridLines = itemstate; Layer.Remove(mrecycler.Unused); Layer.Remove(recycler.Unused); Layer.Add(recycler.Created); Layer.Add(mrecycler.Created); Dirty = false; }