Example #1
0
        public void Update(Size finalSize, Thickness borderThickness, CornerRadius cornerRadius)
        {
            if (borderThickness.IsUniform && cornerRadius.IsUniform)
            {
                _backgroundGeometryCache = null;
                _borderGeometryCache     = null;
                _useComplexRendering     = false;
            }
            else
            {
                _useComplexRendering = true;

                var boundRect = new Rect(finalSize);
                var innerRect = boundRect.Deflate(borderThickness);
                BorderGeometryKeypoints backgroundKeypoints = null;
                StreamGeometry          backgroundGeometry  = null;

                if (innerRect.Width != 0 && innerRect.Height != 0)
                {
                    backgroundGeometry  = new StreamGeometry();
                    backgroundKeypoints = new BorderGeometryKeypoints(innerRect, borderThickness, cornerRadius, true);

                    using (var ctx = backgroundGeometry.Open())
                    {
                        CreateGeometry(ctx, innerRect, backgroundKeypoints);
                    }

                    _backgroundGeometryCache = backgroundGeometry;
                }
                else
                {
                    _backgroundGeometryCache = null;
                }

                if (boundRect.Width != 0 && innerRect.Height != 0)
                {
                    var borderGeometryKeypoints = new BorderGeometryKeypoints(boundRect, borderThickness, cornerRadius, false);
                    var borderGeometry          = new StreamGeometry();

                    using (var ctx = borderGeometry.Open())
                    {
                        CreateGeometry(ctx, boundRect, borderGeometryKeypoints);

                        if (backgroundGeometry != null)
                        {
                            CreateGeometry(ctx, innerRect, backgroundKeypoints);
                        }
                    }

                    _borderGeometryCache = borderGeometry;
                }
                else
                {
                    _borderGeometryCache = null;
                }
            }
        }
Example #2
0
        private static void CreateGeometry(StreamGeometryContext context, Rect boundRect,
                                           BorderGeometryKeypoints keypoints)
        {
            context.BeginFigure(keypoints.TopLeft, true);

            // Top
            context.LineTo(keypoints.TopRight);

            // TopRight corner
            var radiusX = boundRect.TopRight.X - keypoints.TopRight.X;
            var radiusY = keypoints.RightTop.Y - boundRect.TopRight.Y;

            if (radiusX != 0 || radiusY != 0)
            {
                context.ArcTo(keypoints.RightTop, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise);
            }

            // Right
            context.LineTo(keypoints.RightBottom);

            // BottomRight corner
            radiusX = boundRect.BottomRight.X - keypoints.BottomRight.X;
            radiusY = boundRect.BottomRight.Y - keypoints.RightBottom.Y;
            if (radiusX != 0 || radiusY != 0)
            {
                context.ArcTo(keypoints.BottomRight, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise);
            }

            // Bottom
            context.LineTo(keypoints.BottomLeft);

            // BottomLeft corner
            radiusX = keypoints.BottomLeft.X - boundRect.BottomLeft.X;
            radiusY = boundRect.BottomLeft.Y - keypoints.LeftBottom.Y;
            if (radiusX != 0 || radiusY != 0)
            {
                context.ArcTo(keypoints.LeftBottom, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise);
            }

            // Left
            context.LineTo(keypoints.LeftTop);

            // TopLeft corner
            radiusX = keypoints.TopLeft.X - boundRect.TopLeft.X;
            radiusY = keypoints.LeftTop.Y - boundRect.TopLeft.Y;

            if (radiusX != 0 || radiusY != 0)
            {
                context.ArcTo(keypoints.TopLeft, new Size(radiusX, radiusY), 0, false, SweepDirection.Clockwise);
            }

            context.EndFigure(true);
        }
Example #3
0
        void Update(Size finalSize, Thickness borderThickness, CornerRadius cornerRadius)
        {
            _backendSupportsIndividualCorners ??= AvaloniaLocator.Current.GetService <IPlatformRenderInterface>()
            .SupportsIndividualRoundRects;
            _size            = finalSize;
            _borderThickness = borderThickness;
            _cornerRadius    = cornerRadius;
            _initialized     = true;

            if (borderThickness.IsUniform && (cornerRadius.IsUniform || _backendSupportsIndividualCorners == true))
            {
                _backgroundGeometryCache = null;
                _borderGeometryCache     = null;
                _useComplexRendering     = false;
            }
            else
            {
                _useComplexRendering = true;

                var boundRect = new Rect(finalSize);
                var innerRect = boundRect.Deflate(borderThickness);
                BorderGeometryKeypoints backgroundKeypoints = null;
                StreamGeometry          backgroundGeometry  = null;

                if (innerRect.Width != 0 && innerRect.Height != 0)
                {
                    backgroundGeometry  = new StreamGeometry();
                    backgroundKeypoints = new BorderGeometryKeypoints(innerRect, borderThickness, cornerRadius, true);

                    using (var ctx = backgroundGeometry.Open())
                    {
                        CreateGeometry(ctx, innerRect, backgroundKeypoints);
                    }

                    _backgroundGeometryCache = backgroundGeometry;
                }
                else
                {
                    _backgroundGeometryCache = null;
                }

                if (boundRect.Width != 0 && innerRect.Height != 0)
                {
                    var borderGeometryKeypoints = new BorderGeometryKeypoints(boundRect, borderThickness, cornerRadius, false);
                    var borderGeometry          = new StreamGeometry();

                    using (var ctx = borderGeometry.Open())
                    {
                        CreateGeometry(ctx, boundRect, borderGeometryKeypoints);

                        if (backgroundGeometry != null)
                        {
                            CreateGeometry(ctx, innerRect, backgroundKeypoints);
                        }
                    }

                    _borderGeometryCache = borderGeometry;
                }
                else
                {
                    _borderGeometryCache = null;
                }
            }
        }
Example #4
0
        public void Update(Size size, Thickness depth, Thickness extent, CornerRadius radii)
        {
            var boundRect = new Rect(size);
            var innerRect = boundRect.Deflate(depth);
            BorderGeometryKeypoints backgroundKeypoints = null;
            StreamGeometry          backgroundGeometry  = null;

            if (innerRect.Width != 0 && innerRect.Height != 0)
            {
                //new RectangleGeometry()
                //backgroundGeometry = new StreamGeometry();
                //backgroundKeypoints = new BorderGeometryKeypoints(innerRect, new Thickness(depth), radii, true);

                /*using (var ctx = backgroundGeometry.Open())
                 * {
                 *  CreateGeometry(ctx, innerRect, backgroundKeypoints);
                 * }*/

                _middleCenterGeometryCache = backgroundGeometry;
            }
            else
            {
                _middleCenterGeometryCache = null;
            }

            /*if (boundRect.Width != 0 && innerRect.Height != 0)
             * {*/
            //var borderGeometryKeypoints = new BorderGeometryKeypoints(boundRect, depth, radii, false);
            //borderGeometryKeypoints.
            var borderGeometry = new StreamGeometry();

            /*if (backgroundGeometry != null)
             * {
             *  using (var ctx = borderGeometry.Open())
             *  {
             *      CreateGeometry(ctx, innerRect, backgroundKeypoints);
             *  }
             * }*/

            /*if (depth > 0)
             * {*/
            double outerWidth  = extent.Left + radii.TopLeft;
            double outerHeight = extent.Top + radii.TopLeft;

            _topLeftGeometryCache = GetCornerGeometry(new Point(0, outerWidth), new Point(outerHeight, 0), new Point(outerWidth, extent.Top), new Point(extent.Right, outerHeight), new Size(outerWidth, outerHeight), radii.TopLeft, 0, 0);

            double baseCenterWidth = size.Width - (extent.Left + extent.Right);

            _topCenterGeometryCache = new RectangleGeometry(new Rect(outerWidth, 0, baseCenterWidth - (radii.TopLeft + radii.TopRight), extent.Top));

            outerWidth             = extent.Left + radii.TopRight;
            outerHeight            = extent.Top + radii.TopRight;
            _topRightGeometryCache = GetCornerGeometry(new Point(0, 0), new Point(outerWidth, outerHeight), new Point(radii.TopRight, outerHeight), new Point(0, extent.Top), new Size(outerWidth, outerHeight), radii.TopRight, size.Width - outerWidth, 0);

            _bottomCenterGeometryCache = new RectangleGeometry(new Rect(outerWidth, size.Height - extent.Bottom, baseCenterWidth - (radii.BottomLeft + radii.BottomRight), extent.Bottom));

            /*}
             * else
             * {
             *  RectangleGeometry rectG = new RectangleGeometry(new Rect(0, 0, 0, 0));
             *  StreamGeometry streamG = new StreamGeometry();
             *  using (var ctx = streamG.Open())
             *  {
             *      ctx.BeginFigure(new Point(0, 0), true);
             *      ctx.EndFigure(true);
             *  }
             *  _topLeftGeometryCache = streamG;
             *  _middleLeftGeometryCache = rectG;
             *  _topRightGeometryCache = streamG;
             *  _topCenterGeometryCache = rectG;
             *  _bottomRightGeometryCache = streamG;
             *  _middleRightGeometryCache = rectG;
             *  _bottomLeftGeometryCache = streamG;
             *  _bottomCenterGeometryCache = rectG;
             * }*/
        }