/// <summary>
 /// Initialize after entering VT.
 /// </summary>
 /// <param name="icelc"></param>
 void IRequireEnterLeave.Enter(IChartEnterLeaveContext icelc)
 {
     EnsureAxes(icelc as IChartComponentContext);
     EnsureValuePath(icelc as IChartComponentContext);
     Layer = icelc.CreateLayer();
     _trace.Verbose($"{Name} enter v:{ValueAxisName} {ValueAxis} c:{CategoryAxisName} {CategoryAxis} d:{DataSourceName}");
     if (PathTemplate == null)
     {
         if (Theme?.PathTemplate == null)
         {
             if (icelc is IChartErrorInfo icei)
             {
                 icei.Report(new ChartValidationResult(NameOrType(), $"No {nameof(PathTemplate)} and {nameof(Theme.PathTemplate)} was not found", new[] { nameof(PathTemplate), nameof(Theme.PathTemplate) }));
             }
         }
     }
     AssignFromRef(icelc as IChartErrorInfo, NameOrType(), nameof(PathStyle), nameof(Theme.PathColumnSeries),
                   PathStyle == null, Theme != null, Theme.PathColumnSeries != null,
                   () => PathStyle = Theme.PathColumnSeries
                   );
     BindPaths = new Evaluators(CategoryPath, ValuePath, ValueLabelPath);
     if (!BindPaths.IsValid)
     {
         if (icelc is IChartErrorInfo icei)
         {
             icei.Report(new ChartValidationResult(NameOrType(), $"ValuePath: must be specified", new[] { nameof(ValuePath) }));
         }
     }
 }
 /// <summary>
 /// Undo effects of Enter().
 /// </summary>
 /// <param name="icelc"></param>
 void IRequireEnterLeave.Leave(IChartEnterLeaveContext icelc)
 {
     _trace.Verbose($"{Name} leave");
     BindPaths    = null;
     ValueAxis    = null;
     CategoryAxis = null;
     icelc.DeleteLayer(Layer);
     Layer = null;
 }
示例#3
0
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="state">Starting state; SHOULD be empty.</param>
        /// <param name="rc">The recycler.</param>
        /// <param name="evs">Evaluators.</param>
        internal RenderState_ValueAndLabel(List <SIS> state, Recycler <EL, SIS> rc, Evaluators evs) : base(state, rc)
        {
#pragma warning disable IDE0016 // Use 'throw' expression
            if (evs == null)
            {
                throw new ArgumentNullException(nameof(evs));
            }
            if (evs.by == null)
            {
                throw new ArgumentNullException(nameof(evs.by));
            }
#pragma warning restore IDE0016 // Use 'throw' expression
            this.evs = evs;
        }
示例#4
0
 /// <summary>
 /// Initialize after entering VT.
 /// </summary>
 /// <param name="icelc"></param>
 void IRequireEnterLeave.Enter(IChartEnterLeaveContext icelc)
 {
     EnsureAxes(icelc as IChartComponentContext);
     EnsureValuePath(icelc as IChartComponentContext);
     Layer = icelc.CreateLayer(Segments);
     _trace.Verbose($"enter v:{ValueAxisName}:{ValueAxis} c:{CategoryAxisName}:{CategoryAxis} d:{DataSourceName}");
     AssignFromRef(icelc as IChartErrorInfo, NameOrType(), nameof(PathStyle), nameof(Theme.PathLineSeries),
                   PathStyle == null, Theme != null, Theme.PathLineSeries != null,
                   () => PathStyle = Theme.PathLineSeries
                   );
     BindTo(this, nameof(PathStyle), Segments, FrameworkElement.StyleProperty);
     BindPaths = new Evaluators(CategoryPath, ValuePath, ValueLabelPath);
     if (!BindPaths.IsValid)
     {
         // report
     }
 }
示例#5
0
 void IRequireEnterLeave.Enter(IChartEnterLeaveContext icelc)
 {
     EnsureAxes(icelc as IChartComponentContext);
     Layer = icelc.CreateLayer();
     _trace.Verbose($"{Name} enter v:{ValueAxisName} {ValueAxis} c:{CategoryAxisName} {CategoryAxis} d:{DataSourceName}");
     BindPaths = new Evaluators(CategoryPath, ValueLabelPath, ColumnStack.Select(cs => cs.ValuePath));
     if (!BindPaths.IsValid)
     {
         for (int ix = 0; ix < ColumnStack.Count; ix++)
         {
             if (String.IsNullOrEmpty(ColumnStack[ix].ValuePath))
             {
                 if (icelc is IChartErrorInfo icei)
                 {
                     icei.Report(new ChartValidationResult(NameOrType(), $"ValuePath[{ix}] was not set, NO values are generated", new[] { $"ValuePath[{ix}]" }));
                 }
             }
         }
     }
 }
示例#6
0
 /// <summary>
 /// Initialize after entering VT.
 /// </summary>
 /// <param name="icelc"></param>
 public void Enter(IChartEnterLeaveContext icelc)
 {
     EnsureAxes(icelc as IChartComponentContext);
     Layer = icelc.CreateLayer();
     _trace.Verbose($"enter v:{ValueAxisName}:{ValueAxis} c:{CategoryAxisName}:{CategoryAxis} d:{DataSourceName}");
     AssignFromRef(icelc as IChartErrorInfo, NameOrType(), nameof(PathStyle), nameof(Theme.PathMarkerSeries),
                   PathStyle == null, Theme != null, Theme.PathMarkerSeries != null,
                   () => PathStyle = Theme.PathMarkerSeries
                   );
     AssignFromRef(icelc as IChartErrorInfo, NameOrType(), nameof(ReversePathStyle), nameof(PathStyle),
                   ReversePathStyle == null, true, PathStyle != null,
                   () => ReversePathStyle = PathStyle
                   );
     BindPaths = new Evaluators(CategoryPath, OpenValuePath, HighValuePath, LowValuePath, CloseValuePath, ValueLabelPath);
     if (!BindPaths.IsValid)
     {
         if (icelc is IChartErrorInfo icei)
         {
             var props = new List <String>();
             if (String.IsNullOrEmpty(OpenValuePath))
             {
                 props.Add(nameof(OpenValuePath));
             }
             if (String.IsNullOrEmpty(HighValuePath))
             {
                 props.Add(nameof(HighValuePath));
             }
             if (String.IsNullOrEmpty(LowValuePath))
             {
                 props.Add(nameof(LowValuePath));
             }
             if (String.IsNullOrEmpty(CloseValuePath))
             {
                 props.Add(nameof(CloseValuePath));
             }
             icei.Report(new ChartValidationResult(NameOrType(), $"{String.Join(",", props)}: must be specified", props));
         }
     }
 }
        /// <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));
            }
        }
示例#8
0
 internal State(List <ItemState <Path> > sis, Recycler <Path, ItemState <Path> > rc, Evaluators evs) : base(sis, rc)
 {
     this.evs = evs;
 }
示例#9
0
        /// <summary>
        /// Prepare the item state, but no <see cref="Geometry"/>.
        /// </summary>
        /// <param name="index"></param>
        /// <param name="valuex"></param>
        /// <param name="valuey"></param>
        /// <param name="item"></param>
        /// <param name="evs"></param>
        /// <returns></returns>
        ItemState <Path> ElementPipeline(int index, double valuex, double valuey, object item, Evaluators evs)
        {
            var mappedy = ValueAxis.For(valuey);
            var mappedx = CategoryAxis.For(valuex);
            var linex   = mappedx + CategoryAxisOffset;

            _trace.Verbose($"{Name}[{index}] v:({valuex},{valuey}) m:({linex},{mappedy})");
            var cs = evs.LabelFor(item);

            if (cs == null)
            {
                return(new ItemState <Path>(index, mappedx, CategoryAxisOffset, mappedy, Segments));
            }
            else
            {
                return(new ItemStateCustom <Path>(index, mappedx, CategoryAxisOffset, mappedy, cs, Segments));
            }
        }
示例#10
0
        /// <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);
        }
示例#11
0
 internal State(List <SeriesItemState> sis, Recycler <Path, SeriesItemState> rc, Evaluators evs) : base(sis, rc)
 {
     this.evs = evs;
 }
示例#12
0
        /// <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));
            }
        }