Esempio n. 1
0
        public static void DrawSortableValue(this StageVm stageVm, DrawingContext dc,
                                             SortableItemVm sortableVm,
                                             double stageRenderWidth, double stageRenderHeight)
        {
            if ((stageRenderHeight <= 0) || (stageRenderHeight <= 0))
            {
                return;
            }
            if (sortableVm.StagePos == StagePos.Missing)
            {
                return;
            }

            var radius = stageVm.RenderHeight(stageVm.StageVmStyle.KeyLineThickness * 1.5, stageRenderHeight);

            var center = stageVm.GetSortableItemPosition(sortableVm, stageRenderWidth, stageRenderHeight);

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

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

                var upLeft = new Point(center.X - txt.Width / 2, center.Y - txt.Height / 2);
                dc.DrawText(txt, upLeft);
            }
        }
Esempio n. 2
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
                ));
 }
Esempio n. 3
0
 public static SortableItemVm ToMissingSortableVm(this SortableItemVm sortableVm)
 {
     return(new SortableItemVm(
                backgroundBrush: sortableVm.BackgroundBrush,
                foregroundBrush: sortableVm.ForegroundBrush,
                showLabel: sortableVm.ShowLabel,
                stageSection: 0,
                stagePos: StagePos.Missing,
                keyLinePos: sortableVm.KeyLinePos,
                label: sortableVm.Label,
                sortableValue: sortableVm.SortableValue
                ));
 }
Esempio n. 4
0
        public static Tuple <StagePos, int> ToStageSection(
            this SortableItemVm sortableVm, IEnumerable <KeyPairVm> keyPairVms)
        {
            var swH = keyPairVms.FirstOrDefault(
                kpv => (kpv.HiKey == sortableVm.KeyLinePos) ||
                (kpv.LowKey == sortableVm.KeyLinePos)
                );

            if (swH != null)
            {
                return(new Tuple <StagePos, int>(StagePos.Center, swH.StageSection));
            }
            return(new Tuple <StagePos, int>(StagePos.Right, 0));
        }
Esempio n. 5
0
        public static SortableItemVm ToPostSortSortableVm(this SortableItemVm sortableVm, IEnumerable <KeyPairVm> keyPairVms)
        {
            var tup = sortableVm.ToStageSection(keyPairVms);

            return(new SortableItemVm(
                       backgroundBrush: sortableVm.BackgroundBrush,
                       foregroundBrush: sortableVm.ForegroundBrush,
                       showLabel: sortableVm.ShowLabel,
                       stageSection: tup.Item2,
                       stagePos: tup.Item1,
                       keyLinePos: sortableVm.KeyLinePos,
                       label: sortableVm.Label,
                       sortableValue: sortableVm.SortableValue
                       ));
        }
Esempio n. 6
0
        public static Point GetSortableItemPosition(this StageVm stageVm,
                                                    SortableItemVm sortableItemVm,
                                                    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 = stageVm.KeyRenderYc(sortableItemVm.KeyLinePos, stageRenderHeight);
            var radius  = stageVm.RenderHeight(stageVm.StageVmStyle.KeyLineThickness * 1.5, stageRenderHeight);

            var renderX = 0.0;

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

            case StagePos.Center:
                renderX = stageVm.SectionRenderX(sortableItemVm.StageSection, stageRenderWidth);
                break;

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

            default:
                break;
            }
            return(new Point(renderX, renderY));
        }