public ValueRenderRectangle(Double x,
                                    Double y,
                                    Double width,
                                    Double height,
                                    IPoint2D offset)
        {
            X      = x;
            Y      = y;
            Width  = width;
            Height = height;

            if (ReferenceEquals(null, offset))
            {
                throw new ArgumentNullException(nameof(offset));
            }

            Offset = offset;

            TopLeft     = new ValuePoint2D(X, Y);
            TopRight    = new ValuePoint2D(X + Width, Y);
            BottomLeft  = new ValuePoint2D(X, Y + Height);
            BottomRight = new ValuePoint2D(X + Width, Y + Height);

            _hash = 0;
            _hash = GeometryHelper.BuildRectHash(this);
        }
        public override void Arrange <TRenderSize>(TRenderSize availableSpace,
                                                   IRenderContext renderContext)
        {
            // SCROLL PANEL
            var tabPageRect = new ValueRenderRectangle(
                tabsLeft, 0,
                availableSpace.Width,
                availableSpace.Height,
                availableSpace.Offset);
            //new ValuePoint2D(0, 0));
            //renderContext.DrawElement(_scrollPanel, tabPageRect);

            // BOTTOM SEPARATOR
            var separatorRect = new ValueRenderRectangle(
                /* X */ tabsLeft,
                /* Y */ _tabsUsed.Height, //+ SEPARATOR_GAP_TOP,
                /* W */ _tabsUsed.Width,
                /* H */ SEPARATOR_LINE_HEIGHT,
                availableSpace.Offset);

            //renderContext.DrawElement(_separator, separatorRect);


            // INDICATOR
            if (_indicatorRect.IsEmpty)
            {
                if (_itemsControl.SelectedTab != null)
                {
                    if (MoveIndicatorRect())
                    {
                        InvalidateMeasure();
                    }
                }
            }
            else
            {
                var indicatorOffset = new ValuePoint2D(availableSpace.Offset.X +
                                                       _scrollPanel.HorizontalOffset,
                                                       availableSpace.Offset.Y);

                var indicatorRect = new ValueRenderRectangle(
                    0 - _scrollPanel.HorizontalOffset,
                    availableSpace.Height - (/*SEPARATOR_GAP_BOTTOM +*/ INDICATOR_LINE_HEIGHT),
                    _indicatord,
                    indicatorOffset);

                renderContext.DrawElement(_indicator, indicatorRect);
            }


            renderContext.DrawElement(_separator, separatorRect);
            renderContext.DrawElement(_scrollPanel, tabPageRect);
        }
示例#3
0
        public override void Arrange <TRenderSize>(TRenderSize availableSpace,
                                                   IRenderContext renderContext)
        {
            var h      = availableSpace.Height * 0.7;
            var center = new ValuePoint2D(0, h);

            if (Brush is { } brush)
            {
                renderContext.FillPie(center, h, 0, -90, brush);
            }
            var rect = new ValueRenderRectangle(_offsetX, 0,
                                                availableSpace.Width - _offsetX, h, Point2D.Empty);

            renderContext.DrawElement(_label, rect);
        }
        public ValueRenderRectangle(IPoint2D position,
                                    ISize renderSize,
                                    IPoint2D offset,
                                    Thickness?padding)
        {
            if (padding?.IsEmpty == false)
            {
                X      = position.X + padding.Left;
                Y      = position.Y + padding.Top;
                Width  = renderSize.Width - padding.Width;
                Height = renderSize.Height - padding.Height;
            }
            else
            {
                X      = position.X;
                Y      = position.Y;
                Width  = renderSize.Width;
                Height = renderSize.Height;
            }

            if (ReferenceEquals(null, offset))
            {
                throw new ArgumentNullException(nameof(offset));
            }

            Offset = offset;

            TopLeft     = new ValuePoint2D(X, Y);
            TopRight    = new ValuePoint2D(X + Width, Y);
            BottomLeft  = new ValuePoint2D(X, Y + Height);
            BottomRight = new ValuePoint2D(X + Width, Y + Height);


            _hash = 0;
            _hash = GeometryHelper.BuildRectHash(this);
        }
        public override void Arrange <TRenderSize>(TRenderSize availableSpace,
                                                   IRenderContext renderContext)
        {
            var side = Math.Min(availableSpace.Width, availableSpace.Height);

            if (side.IsZero() || !(DataContext is {} binding))

            {
                return;
            }

            renderContext.FillRectangle(availableSpace.ToFullRectangle(),
                                        renderContext.ColorPalette.Background);

            var radius = side / 2;
            var center = new ValuePoint2D(availableSpace.Width - side + radius,
                                          availableSpace.Height - side + side / 2);

            var currentValue = binding as IPieData <TKey, TValue>;

            if (currentValue == null)
            {
                return;
            }

            var data = currentValue.Items.ToArray();

            var pntCnt  = data.Length;
            var doubles = new Double[pntCnt];

            Double valSum    = 0;
            var    anglePcts = new Double[pntCnt];

            for (var c = 0; c < pntCnt; c++)
            {
                var dbl = Convert.ToDouble(data[c].Value);
                doubles[c] = dbl;
                valSum    += dbl;
            }

            for (var c = 0; c < pntCnt; c++)
            {
                anglePcts[c] = doubles[c] / valSum * 360;
            }

            var currentRadius = 0.0;

            for (var c = 0; c < pntCnt; c++)
            {
                var current = data[c];
                var val     = anglePcts[c] + currentRadius;
                var brush   = GetBrush(currentValue, current);

                renderContext.FillPie(center, radius, currentRadius, val, brush);

                currentRadius = val;
            }

            //elliptical border
            renderContext.DrawEllipse(center, radius, _outline);

            ArrangeLegend(renderContext);
        }