示例#1
0
 public static SortableItemVm Copy(this SortableItemVm sortableItemVm)
 {
     return(new SortableItemVm(
                backgroundBrush: sortableItemVm.BackgroundBrush,
                foregroundBrush: sortableItemVm.ForegroundBrush,
                stageSection: sortableItemVm.StageSection,
                stagePos: sortableItemVm.StagePos,
                keyLinePos: sortableItemVm.KeyLinePos,
                showLabel: sortableItemVm.ShowLabel,
                label: sortableItemVm.Label,
                sortableValue: sortableItemVm.SortableValue
                ));
 }
示例#2
0
 public static SortableItemVm ToMissingSortableItemVm(this SortableItemVm sortableItemVm)
 {
     return(new SortableItemVm(
                backgroundBrush: sortableItemVm.BackgroundBrush,
                foregroundBrush: sortableItemVm.ForegroundBrush,
                showLabel: sortableItemVm.ShowLabel,
                stageSection: 0,
                stagePos: StagePos.Missing,
                keyLinePos: sortableItemVm.KeyLinePos,
                label: sortableItemVm.Label,
                sortableValue: sortableItemVm.SortableValue
                ));
 }
示例#3
0
        public static Tuple <StagePos, int> ToStageSection(
            this SortableItemVm sortableItemVm, IEnumerable <KeyPairVm> keyPairVms)
        {
            var keyPairVm = keyPairVms.FirstOrDefault(
                kpv => (kpv.HiKey == sortableItemVm.KeyLinePos) ||
                (kpv.LowKey == sortableItemVm.KeyLinePos)
                );

            if (keyPairVm != null)
            {
                return(new Tuple <StagePos, int>(StagePos.Center, keyPairVm.StageSection));
            }
            return(new Tuple <StagePos, int>(StagePos.Right, 0));
        }
示例#4
0
        public static SortableItemVm ToPostSortSortableItemVm(this SortableItemVm sortableItemVm,
                                                              IEnumerable <KeyPairVm> keyPairVms)
        {
            var tup = sortableItemVm.ToStageSection(keyPairVms);

            return(new SortableItemVm(
                       backgroundBrush: sortableItemVm.BackgroundBrush,
                       foregroundBrush: sortableItemVm.ForegroundBrush,
                       showLabel: sortableItemVm.ShowLabel,
                       stageSection: tup.Item2,
                       stagePos: tup.Item1,
                       keyLinePos: sortableItemVm.KeyLinePos,
                       label: sortableItemVm.Label,
                       sortableValue: sortableItemVm.SortableValue
                       ));
        }
示例#5
0
        public static Point GetSortableItemPosition(this SortableItemVm sortableItemVm,
                                                    SortableVmStyle sortableVmStyle,
                                                    double stageRenderWidth,
                                                    double stageRenderHeight)
        {
            if ((stageRenderHeight <= 0) || (stageRenderHeight <= 0))
            {
                return(new Point(0, 0));
            }
            if (sortableItemVm.StagePos == StagePos.Missing)
            {
                return(new Point(0, 0));
            }

            var renderY = sortableVmStyle.RenderYKeyLineCenter(sortableItemVm.KeyLinePos, stageRenderHeight);

            var radius =
                RenderUtils.ChildRenderHeight(
                    parentVmHeight: sortableVmStyle.StageVmHeight(),
                    childVmHeight: sortableVmStyle.Radius,
                    parentRenderHeight: stageRenderHeight);

            var renderX = 0.0;

            switch (sortableItemVm.StagePos)
            {
            case StagePos.Left:
                renderX = radius * -1.2;
                break;

            case StagePos.Center:
                renderX = sortableVmStyle
                          .RenderXMidStageSection(
                    sortableItemVm.StageSection, stageRenderWidth);
                break;

            case StagePos.Right:
                renderX = stageRenderWidth - radius * 1.2;
                break;

            default:
                break;
            }

            return(new Point(renderX, renderY));
        }
示例#6
0
        public static void DrawSortableValue(this DrawingContext dc,
                                             SortableVmStyle sortableVmStyle,
                                             SortableItemVm sortableItemVm,
                                             double stageRenderWidth,
                                             double stageRenderHeight)
        {
            if ((stageRenderHeight <= 0) || (stageRenderHeight <= 0))
            {
                return;
            }
            if (sortableItemVm.StagePos == StagePos.Missing)
            {
                return;
            }

            var radius = RenderUtils.ChildRenderHeight(
                parentVmHeight: sortableVmStyle.StageVmHeight(),
                childVmHeight: sortableVmStyle.Radius,
                parentRenderHeight: stageRenderHeight);

            var sortableItemPosition = sortableItemVm.GetSortableItemPosition(
                sortableVmStyle: sortableVmStyle,
                stageRenderWidth: stageRenderWidth,
                stageRenderHeight: stageRenderHeight);

            dc.DrawEllipse(sortableItemVm.BackgroundBrush, SortableBorderPen, sortableItemPosition, radius, radius);

            if (sortableItemVm.ShowLabel)
            {
                var txt = new FormattedText(sortableItemVm.Label.ToString(),
                                            CultureInfo.CurrentCulture,
                                            FlowDirection.LeftToRight,
                                            SortableItemVm.Typeface,
                                            radius, sortableItemVm.ForegroundBrush, 1.0);

                var textUpLeft = new Point(
                    x: sortableItemPosition.X - txt.Width / 2,
                    y: sortableItemPosition.Y - txt.Height / 2);

                dc.DrawText(txt, textUpLeft);
            }
        }
示例#7
0
        public static void DrawSortableValueAnimate(
            this DrawingContext dc,
            double animationPct,
            SortableVmStyle sortableVmStyle,
            SortableItemVm sortableItemVmOld,
            SortableItemVm sortableItemVm,
            double stageRenderWidth,
            double stageRenderHeight)
        {
            if ((stageRenderHeight <= 0) || (stageRenderHeight <= 0))
            {
                return;
            }
            if (sortableItemVm.StagePos == StagePos.Missing)
            {
                return;
            }
            var radius =
                RenderUtils.ChildRenderHeight(parentVmHeight: sortableVmStyle.StageVmHeight(),
                                              childVmHeight: sortableVmStyle.Radius,
                                              parentRenderHeight: stageRenderHeight);

            var centerO = sortableItemVmOld.GetSortableItemPosition(sortableVmStyle, stageRenderWidth, stageRenderHeight);
            var centerN = sortableItemVm.GetSortableItemPosition(sortableVmStyle, stageRenderWidth, stageRenderHeight);

            var center = centerO.Interpolate(centerN, animationPct);

            dc.DrawEllipse(sortableItemVm.BackgroundBrush, null, center, radius, radius);

            if (sortableItemVm.ShowLabel)
            {
                var txt = new FormattedText(sortableItemVm.Label.ToString(),
                                            CultureInfo.CurrentCulture,
                                            FlowDirection.LeftToRight,
                                            SortableItemVm.Typeface,
                                            radius, sortableItemVm.ForegroundBrush, 1.0);

                var upLeft = new Point(center.X - txt.Width / 2, center.Y - txt.Height / 2);
                dc.DrawText(txt, upLeft);
            }
        }