Esempio n. 1
0
        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
        {
            base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
            var measureWidth  = MeasureSpecFactory.GetSize(widthMeasureSpec);
            var measureHeight = MeasureSpecFactory.GetSize(heightMeasureSpec);

            SetMeasuredDimension(measureWidth, (int)Context.ToPixels(35));
        }
Esempio n. 2
0
        public override SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint)
        {
            if (_lastSizeRequest.HasValue)
            {
                // if we are measuring the same thing, no need to waste the time
                bool canRecycleLast = widthConstraint == _lastConstraintWidth && heightConstraint == _lastConstraintHeight;

                if (!canRecycleLast)
                {
                    // if the last time we measured the returned size was all around smaller than the passed constraint
                    // and the constraint is bigger than the last size request, we can assume the newly measured size request
                    // will not change either.
                    int lastConstraintWidthSize  = MeasureSpecFactory.GetSize(_lastConstraintWidth);
                    int lastConstraintHeightSize = MeasureSpecFactory.GetSize(_lastConstraintHeight);

                    int currentConstraintWidthSize  = MeasureSpecFactory.GetSize(widthConstraint);
                    int currentConstraintHeightSize = MeasureSpecFactory.GetSize(heightConstraint);

                    bool lastWasSmallerThanConstraints = _lastSizeRequest.Value.Request.Width < lastConstraintWidthSize && _lastSizeRequest.Value.Request.Height < lastConstraintHeightSize;

                    bool currentConstraintsBiggerThanLastRequest = currentConstraintWidthSize >= _lastSizeRequest.Value.Request.Width && currentConstraintHeightSize >= _lastSizeRequest.Value.Request.Height;

                    canRecycleLast = lastWasSmallerThanConstraints && currentConstraintsBiggerThanLastRequest;
                }

                if (canRecycleLast)
                {
                    return(_lastSizeRequest.Value);
                }
            }

            //We need to clear the Hint or else it will interfere with the sizing of the Label
            var hint = Control.Hint;

            if (!string.IsNullOrEmpty(hint))
            {
                Control.Hint = string.Empty;
            }

            SizeRequest result = base.GetDesiredSize(widthConstraint, heightConstraint);

            //Set Hint back after sizing
            Control.Hint = hint;

            result.Minimum = new Size(Math.Min(Context.ToPixels(10), result.Request.Width), result.Request.Height);

            _lastConstraintWidth  = widthConstraint;
            _lastConstraintHeight = heightConstraint;
            _lastSizeRequest      = result;

            return(result);
        }
Esempio n. 3
0
        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
        {
            SetMeasuredDimension(MeasureSpec.GetSize(widthMeasureSpec), MeasureSpec.GetSize(heightMeasureSpec));

            var width  = MeasureSpecFactory.GetSize(widthMeasureSpec);
            var height = MeasureSpecFactory.GetSize(heightMeasureSpec);

            for (int i = 0; i < ChildCount; i++)
            {
                var child = GetChildAt(i);
                child.Measure(MeasureSpecFactory.MakeMeasureSpec(width, MeasureSpecMode.Exactly),
                              MeasureSpecFactory.MakeMeasureSpec(height, MeasureSpecMode.Exactly));
            }
        }
Esempio n. 4
0
        protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
        {
            if (View == null)
            {
                SetMeasuredDimension(0, 0);
                return;
            }

            // chain on down
            _renderer.View.Measure(widthMeasureSpec, heightMeasureSpec);

            var width  = MeasureSpecFactory.GetSize(widthMeasureSpec);
            var height = MeasureSpecFactory.GetSize(heightMeasureSpec);

            var measureWidth  = width > 0 ? _context.FromPixels(width) : double.PositiveInfinity;
            var measureHeight = height > 0 ? _context.FromPixels(height) : double.PositiveInfinity;

            var sizeReq = View.Measure(measureWidth, measureHeight);

            SetMeasuredDimension((MatchWidth && width != 0) ? width : (int)_context.ToPixels(sizeReq.Request.Width),
                                 (MatchHeight && height != 0) ? height : (int)_context.ToPixels(sizeReq.Request.Height));
        }
Esempio n. 5
0
            protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
            {
                if (_child?.Element == null)
                {
                    SetMeasuredDimension(0, 0);
                    return;
                }

                VisualElement element = _child.Element;

                Context ctx = Context;

                var width = (int)ctx.FromPixels(MeasureSpecFactory.GetSize(widthMeasureSpec));

                SizeRequest request = element.Measure(width, double.PositiveInfinity, MeasureFlags.IncludeMargins);

                System.Maui.Layout.LayoutChildIntoBoundingRegion(element, new Rectangle(0, 0, width, request.Request.Height));

                int widthSpec  = MeasureSpecFactory.MakeMeasureSpec((int)ctx.ToPixels(width), MeasureSpecMode.Exactly);
                int heightSpec = MeasureSpecFactory.MakeMeasureSpec((int)ctx.ToPixels(request.Request.Height), MeasureSpecMode.Exactly);

                _child.View.Measure(widthMeasureSpec, heightMeasureSpec);
                SetMeasuredDimension(widthSpec, heightSpec);
            }