C# Size.WithWidth方法代码示例

        protected override Size MeasureOverride(Size availableSize)
        {
            var content = Content as ILayoutable;

            if (content != null)
            {
                var measureSize = new Size(double.PositiveInfinity, double.PositiveInfinity);

                if (!CanScrollHorizontally)
                {
                    measureSize = measureSize.WithWidth(availableSize.Width);
                }

                content.Measure(measureSize);
                var size = content.DesiredSize;
                _measuredExtent = size;
                return size.Constrain(availableSize);
            }
            else
            {
                return Extent = new Size();
            }
        }

        /// <inheritdoc/>
        protected override Size MeasureOverride(Size availableSize)
        {
            var child = Child;

            if (child != null)
            {
                var measureSize = availableSize;

                if (_scrollableSubscription == null)
                {
                    measureSize = new Size(double.PositiveInfinity, double.PositiveInfinity);

                    if (!CanScrollHorizontally)
                    {
                        measureSize = measureSize.WithWidth(availableSize.Width);
                    }
                }

                child.Measure(measureSize);
                var size = child.DesiredSize;
                _measuredExtent = size;
                return size.Constrain(availableSize);
            }
            else
            {
                return Extent = new Size();
            }
        }

        /// <inheritdoc/>
        public override Size MeasureOverride(Size availableSize)
        {
            var window = Owner.GetVisualRoot() as TopLevel;

            // If infinity is passed as the available size and we're virtualized then we need to
            // fill the available space, but to do that we *don't* want to materialize all our
            // items! Take a look at the root of the tree for a MaxClientSize and use that as
            // the available size.
            if (VirtualizingPanel.ScrollDirection == Orientation.Vertical)
            {
                if (availableSize.Height == double.PositiveInfinity)
                {
                    if (window != null)
                    {
                        availableSize = availableSize.WithHeight(window.PlatformImpl.MaxClientSize.Height);
                    }
                }

                availableSize = availableSize.WithWidth(double.PositiveInfinity);
            }
            else
            {
                if (availableSize.Width == double.PositiveInfinity)
                {
                    if (window != null)
                    {
                        availableSize = availableSize.WithWidth(window.PlatformImpl.MaxClientSize.Width);
                    }
                }

                availableSize = availableSize.WithHeight(double.PositiveInfinity);
            }

            Owner.Panel.Measure(availableSize);
            return Owner.Panel.DesiredSize;
        }

        private Size ComputeLargestTransformedSize(Size arrangeBounds)
        {
            // Computed largest transformed size
            Size computedSize = Size.Empty;

            // Detect infinite bounds and constrain the scenario
            bool infiniteWidth = double.IsInfinity(arrangeBounds.Width);
            if (infiniteWidth)
            {
                // arrangeBounds.Width = arrangeBounds.Height;
                arrangeBounds = arrangeBounds.WithWidth(arrangeBounds.Height);
            }
            bool infiniteHeight = double.IsInfinity(arrangeBounds.Height);
            if (infiniteHeight)
            {
                //arrangeBounds.Height = arrangeBounds.Width;
                arrangeBounds = arrangeBounds.WithHeight(arrangeBounds.Width);
            }

            // Capture the matrix parameters
            double a = _transformation.M11;
            double b = _transformation.M12;
            double c = _transformation.M21;
            double d = _transformation.M22;

            // Compute maximum possible transformed width/height based on starting width/height
            // These constraints define two lines in the positive x/y quadrant
            double maxWidthFromWidth = Math.Abs(arrangeBounds.Width / a);
            double maxHeightFromWidth = Math.Abs(arrangeBounds.Width / c);
            double maxWidthFromHeight = Math.Abs(arrangeBounds.Height / b);
            double maxHeightFromHeight = Math.Abs(arrangeBounds.Height / d);

            // The transformed width/height that maximize the area under each segment is its midpoint
            // At most one of the two midpoints will satisfy both constraints
            double idealWidthFromWidth = maxWidthFromWidth / 2;
            double idealHeightFromWidth = maxHeightFromWidth / 2;
            double idealWidthFromHeight = maxWidthFromHeight / 2;
            double idealHeightFromHeight = maxHeightFromHeight / 2;

            // Compute slope of both constraint lines
            double slopeFromWidth = -(maxHeightFromWidth / maxWidthFromWidth);
            double slopeFromHeight = -(maxHeightFromHeight / maxWidthFromHeight);

            if ((0 == arrangeBounds.Width) || (0 == arrangeBounds.Height))
            {
                // Check for empty bounds
                computedSize = new Size(arrangeBounds.Width, arrangeBounds.Height);
            }
            else if (infiniteWidth && infiniteHeight)
            {
                // Check for completely unbound scenario
                computedSize = new Size(double.PositiveInfinity, double.PositiveInfinity);
            }
            else if (!_transformation.HasInverse)
            {
                // Check for singular matrix
                computedSize = new Size(0, 0);
            }
            else if ((0 == b) || (0 == c))
            {
                // Check for 0/180 degree special cases
                double maxHeight = (infiniteHeight ? double.PositiveInfinity : maxHeightFromHeight);
                double maxWidth = (infiniteWidth ? double.PositiveInfinity : maxWidthFromWidth);
                if ((0 == b) && (0 == c))
                {
                    // No constraints
                    computedSize = new Size(maxWidth, maxHeight);
                }
                else if (0 == b)
                {
                    // Constrained by width
                    double computedHeight = Math.Min(idealHeightFromWidth, maxHeight);
                    computedSize = new Size(
                        maxWidth - Math.Abs((c * computedHeight) / a),
                        computedHeight);
                }
                else if (0 == c)
                {
                    // Constrained by height
                    double computedWidth = Math.Min(idealWidthFromHeight, maxWidth);
                    computedSize = new Size(
                        computedWidth,
                        maxHeight - Math.Abs((b * computedWidth) / d));
                }
            }
            else if ((0 == a) || (0 == d))
            {
                // Check for 90/270 degree special cases
                double maxWidth = (infiniteHeight ? double.PositiveInfinity : maxWidthFromHeight);
                double maxHeight = (infiniteWidth ? double.PositiveInfinity : maxHeightFromWidth);
                if ((0 == a) && (0 == d))
                {
                    // No constraints
                    computedSize = new Size(maxWidth, maxHeight);
                }
                else if (0 == a)
                {
                    // Constrained by width
                    double computedHeight = Math.Min(idealHeightFromHeight, maxHeight);
                    computedSize = new Size(
//.........这里部分代码省略.........