protected override SizeRequest OnSizeRequest(double widthConstraint, double heightConstraint) { if (!InternalChildren.Any()) return new SizeRequest(new Size(0, 0)); MeasureGrid(widthConstraint, heightConstraint, true); double columnWidthSum = 0; double nonStarColumnWidthSum = 0; for (var index = 0; index < _columns.Count; index++) { ColumnDefinition c = _columns[index]; columnWidthSum += c.ActualWidth; if (!c.Width.IsStar) nonStarColumnWidthSum += c.ActualWidth; } double rowHeightSum = 0; double nonStarRowHeightSum = 0; for (var index = 0; index < _rows.Count; index++) { RowDefinition r = _rows[index]; rowHeightSum += r.ActualHeight; if (!r.Height.IsStar) nonStarRowHeightSum += r.ActualHeight; } var request = new Size(columnWidthSum + (_columns.Count - 1) * ColumnSpacing, rowHeightSum + (_rows.Count - 1) * RowSpacing); var minimum = new Size(nonStarColumnWidthSum + (_columns.Count - 1) * ColumnSpacing, nonStarRowHeightSum + (_rows.Count - 1) * RowSpacing); var result = new SizeRequest(request, minimum); return result; }
protected override SizeRequest OnSizeRequest(double widthConstraint, double heightConstraint) { if (Math.Abs (oldWidth - widthConstraint) > double.Epsilon || Math.Abs (oldHeight - heightConstraint) > double.Epsilon) { Debug.WriteLine ("**- OnSizeRequest TAB {0} {1}", widthConstraint, heightConstraint); oldSizeRequest = base.OnSizeRequest (widthConstraint, heightConstraint); oldWidth = widthConstraint; oldHeight = heightConstraint; } return oldSizeRequest; }
public SizeRequest Measure(ISet<State> states, Size availableSize, SizeRequest contentSize) { if (Font == null || Text == null) return default(SizeRequest); var textMeasure = Font.MeasureString(Text); var originalFontSize = textMeasure.Y * 72 / 96.0f; var scale = FontSize / originalFontSize; return new SizeRequest(new Size(textMeasure.X * scale, textMeasure.Y * scale)); }
protected override SizeRequest OnSizeRequest(double widthConstraint, double heightConstraint) { double widthRequest = WidthRequest; double heightRequest = HeightRequest; var childRequest = new SizeRequest(); if ((widthRequest == -1 || heightRequest == -1) && Content != null) { childRequest = Content.Measure(widthConstraint, heightConstraint, MeasureFlags.IncludeMargins); } return new SizeRequest { Request = new Size { Width = widthRequest != -1 ? widthRequest : childRequest.Request.Width, Height = heightRequest != -1 ? heightRequest : childRequest.Request.Height }, Minimum = childRequest.Minimum }; }
protected override SizeRequest OnSizeRequest(double widthConstraint, double heightConstraint) { double widthRequest = WidthRequest; double heightRequest = HeightRequest; var childRequest = new SizeRequest(); if ((widthRequest == -1 || heightRequest == -1) && InternalChildren.Count > 0) { childRequest = ((View)InternalChildren[0]).Measure(widthConstraint, heightConstraint, MeasureFlags.IncludeMargins); } return new SizeRequest { Request = new Size { Width = widthRequest != -1 ? widthRequest : childRequest.Request.Width, Height = heightRequest != -1 ? heightRequest : childRequest.Request.Height }, Minimum = childRequest.Minimum }; }
protected override void LayoutChildren(double x, double y, double width, double height) { IList <View> children = new List <View>(); SizeRequest childSizeRequest = default(SizeRequest); foreach (var child in Children) { if (!child.IsVisible) { continue; } childSizeRequest = child.GetSizeRequest(double.PositiveInfinity, height); double childWidth = childSizeRequest.Request.Width; double childHeight = childSizeRequest.Request.Height; if (x + childWidth >= width) { FlexLine flexLine = GenerateFlexLine(children); SizeRequest flexLineSizeRequest = flexLine.GetSizeRequest(double.PositiveInfinity, height); double flexLineWidth = childSizeRequest.Request.Width; double flexLineHeight = childSizeRequest.Request.Height; LayoutChildIntoBoundingRegion(flexLine, new Rectangle(0, y, width, flexLineHeight)); x = 0; y += flexLineHeight; //DependingFlexOrientation(flexLine.CrossSize(height), flexLine.CrossSize(width)); children.Clear(); } children.Add(child); x += (childWidth + Spacing); //DependingFlexOrientation(() => { x += (childWidth + Spacing); }, () => { y += (childHeight + Spacing); }); } FlexLine lastFlexLine = GenerateFlexLine(children); SizeRequest lastFlexLineSizeRequest = lastFlexLine.GetSizeRequest(double.PositiveInfinity, height); double lastFlexLineWidth = childSizeRequest.Request.Width; double lastFlexLineHeight = childSizeRequest.Request.Height; LayoutChildIntoBoundingRegion(lastFlexLine, new Rectangle(0, y, width, lastFlexLineHeight)); }
/// <summary> /// Measure view size /// </summary> protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { SizeRequest s = new SizeRequest(); if (IsAnimationRunning) { s.Minimum = new Size(m_contentSize.Width, m_contentSize.Height + m_expandingHeight); s.Request = new Size(m_contentSize.Width, m_contentSize.Height + m_expandingHeight); } else { s = base.OnMeasure(widthConstraint, heightConstraint); m_contentSize = s.Request; if (ExpandingContent != null && ExpandingContent.IsVisible && IsExpanded) { m_expandingContentSize = ExpandingContent.Measure(widthConstraint, heightConstraint, MeasureFlags.IncludeMargins).Request; if (MaxExpandLenght < double.MaxValue) { m_expandingContentSize.Height = Math.Min(MaxExpandLenght, m_expandingContentSize.Height); } switch (ExpandingDirection) { case ExpandingDirections.Left: case ExpandingDirections.Right: s.Minimum = new Size(s.Minimum.Width + m_expandingContentSize.Width, s.Minimum.Height); s.Request = new Size(s.Request.Width + m_expandingContentSize.Width, s.Request.Height); break; case ExpandingDirections.Top: case ExpandingDirections.Bottom: s.Minimum = new Size(s.Minimum.Width, s.Minimum.Height + m_expandingContentSize.Height); s.Request = new Size(s.Request.Width, s.Request.Height + m_expandingContentSize.Height); break; } } } return(s); }
protected override void LayoutChildren(double x, double y, double width, double height) { foreach (View child in Children) { // Skip the invisible children. if (!child.IsVisible) { continue; } // Get the child's requested size. SizeRequest childSizeRequest = child.Measure(width, Double.PositiveInfinity); // Initialize child position and size. double xChild = x; double yChild = y; double childWidth = childSizeRequest.Request.Width; double childHeight = childSizeRequest.Request.Height; // Adjust position and size based on HorizontalOptions. switch (child.HorizontalOptions.Alignment) { case LayoutAlignment.Start: break; case LayoutAlignment.Center: xChild += (width - childWidth) / 2; break; case LayoutAlignment.End: xChild += (width - childWidth); break; case LayoutAlignment.Fill: childWidth = width; break; } // Layout the child. //child.Layout(new Rectangle(xChild, yChild, childWidth, childHeight)); LayoutChildIntoBoundingRegion(child, new Rectangle(xChild, yChild, childWidth, childHeight)); // Get the next child’s vertical position. y += childHeight; } }
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); } } SizeRequest result = base.GetDesiredSize(widthConstraint, heightConstraint); result.Minimum = new Size(Math.Min(Context.ToPixels(10), result.Request.Width), result.Request.Height); _lastConstraintWidth = widthConstraint; _lastConstraintHeight = heightConstraint; _lastSizeRequest = result; return(result); }
protected override void LayoutChildren(double x, double y, double width, double height) { double crossSize = 0; crossSize = DependingFlexOrientation(CrossSize(width), CrossSize(height)); foreach (var child in Children) { if (!child.IsVisible) { continue; } SizeRequest childSizeRequest = child.GetSizeRequest(double.PositiveInfinity, height); double childWidth = childSizeRequest.Request.Width; double childHeight = childSizeRequest.Request.Height; LayoutChildIntoBoundingRegion(child, AlignItemsSwitch(crossSize, x, y, childWidth, childHeight)); DependingFlexOrientation(() => { x += (childWidth + Spacing); }, () => { y += (childHeight + Spacing); }); } }
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec) { Performance.Start(out string reference); int width = MeasureSpec.GetSize(widthMeasureSpec); int height; if (ParentHasUnevenRows) { SizeRequest measure = _view.Element.Measure(Context.FromPixels(width), double.PositiveInfinity, MeasureFlags.IncludeMargins); height = (int)Context.ToPixels(_viewCell.Height > 0 ? _viewCell.Height : measure.Request.Height); } else { height = (int)Context.ToPixels(ParentRowHeight == -1 ? BaseCellView.DefaultMinHeight : ParentRowHeight); } SetMeasuredDimension(width, height); Performance.Stop(reference); }
public override SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint) { SizeRequest sizeConstraint = base.GetDesiredSize(widthConstraint, heightConstraint); if (sizeConstraint.Request.Width == 0) { int width = widthConstraint; if (widthConstraint <= 0) { width = (int)Context.GetThemeAttributeDp(global::Android.Resource.Attribute.SwitchMinWidth); } else if (widthConstraint <= 0) { width = 100; } sizeConstraint = new SizeRequest(new Size(width, sizeConstraint.Request.Height), new Size(width, sizeConstraint.Minimum.Height)); } return(sizeConstraint); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { Size reqSize = new Size(); Size minSize = new Size(); foreach (Xamarin.Forms.View child in Children) { if (!child.IsVisible) { continue; } SizeRequest childSizeRequest = child.Measure(widthConstraint, Double.PositiveInfinity, MeasureFlags.IncludeMargins); reqSize.Width = Math.Max(reqSize.Width, childSizeRequest.Request.Width); reqSize.Height += childSizeRequest.Request.Height; minSize.Width = Math.Max(minSize.Width, childSizeRequest.Minimum.Width); minSize.Height += childSizeRequest.Minimum.Height; } return(new SizeRequest(reqSize, minSize)); }
public SizeRequest GetSize(Size availableSize) { SizeRequest s = new SizeRequest(); if (m_sizeCache.TryGetValue(availableSize, out s) == false) { if (View.WidthRequest >= 0 && View.HeightRequest >= 0) { s = new SizeRequest(new Size(View.WidthRequest + View.Margin.HorizontalThickness, View.HeightRequest + View.Margin.VerticalThickness), new Size(View.WidthRequest + View.Margin.HorizontalThickness, View.HeightRequest + View.Margin.VerticalThickness)); } else { s = View.Measure(availableSize.Width, availableSize.Height, MeasureFlags.IncludeMargins); // System.Diagnostics.Debug.WriteLine("Actual measure: " + View.ToString()); } m_sizeCache.Add(availableSize, s); } return(s); }
Rectangle ComputeLayoutForRegion(View view) { double xScale = Width / (IntendedWidth == autoSize ? Width : IntendedWidth), yScale = Height / (IntendedHeight == autoSize ? Height : IntendedHeight); Point location = GetLocation(view); Size size = GetSize(view); var result = new Rectangle { X = location.X * xScale, Y = location.Y * yScale }; if (size.Width == autoSize && size.Height == autoSize) { SizeRequest sizeRequest = view.Measure(Width, Height, MeasureFlags.IncludeMargins); result.Width = sizeRequest.Request.Width * xScale; result.Height = sizeRequest.Request.Height * yScale; } else if (size.Width == autoSize) { SizeRequest sizeRequest = view.Measure(Width, Height, MeasureFlags.IncludeMargins); result.Width = sizeRequest.Request.Width * xScale; result.Height = size.Height * yScale; } else if (size.Height == autoSize) { SizeRequest sizeRequest = view.Measure(Width, Height, MeasureFlags.IncludeMargins); result.Width = size.Width * xScale; result.Height = sizeRequest.Request.Height * yScale; } else { result.Width = size.Width * xScale; result.Height = size.Height * yScale; } return(result); }
/// <summary> /// 対象のレイアウトを格納するBOXのサイズ(width,height)を設定する。 /// </summary> /// <returns>The measure.</returns> /// <param name="widthConstraint">Width constraint.</param> /// <param name="heightConstraint">Height constraint.</param> protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { // 対象要素のheightの設定 // widthはwidthConstraintの値 // ※実質1行の高さは同じなので、高さは(1行の高さ*行数)+((行数-1)*スペース) となる double width = widthConstraint; int countChildren = Children.Count; int countRows = 1; double tmpWidthPerRow = 0; double?heightPerRow = null; foreach (View child in Children) { // 子要素のサイズを取得 SizeRequest childSizeRequest = child.Measure(Double.PositiveInfinity, Double.PositiveInfinity); // 1行の幅が全体幅を上回れば行を追加 tmpWidthPerRow += childSizeRequest.Request.Width; if (tmpWidthPerRow >= width) { // 1行幅のリセット tmpWidthPerRow = childSizeRequest.Request.Width; // 行を1行追加 countRows++; } // 1行の高さを保存 if (!heightPerRow.HasValue) { heightPerRow = childSizeRequest.Request.Height; } } // 高さの設定 double height = (double)heightPerRow * countRows + RowSpacing * (countRows - 1); return(new SizeRequest(new Size(width, height))); }
public static SizeRequest GetNativeSize( IVisualElementRenderer visualElementRenderer, double widthConstraint, double heightConstraint) { var context = visualElementRenderer.View.Context; // negative numbers have special meanings to android they don't to us widthConstraint = widthConstraint <= -1 ? double.PositiveInfinity : context.ToPixels(widthConstraint); heightConstraint = heightConstraint <= -1 ? double.PositiveInfinity : context.ToPixels(heightConstraint); bool widthConstrained = !double.IsPositiveInfinity(widthConstraint); bool heightConstrained = !double.IsPositiveInfinity(heightConstraint); int widthMeasureSpec = widthConstrained ? MeasureSpecFactory.MakeMeasureSpec((int)widthConstraint, MeasureSpecMode.AtMost) : MeasureSpecFactory.MakeMeasureSpec(0, MeasureSpecMode.Unspecified); int heightMeasureSpec = heightConstrained ? MeasureSpecFactory.MakeMeasureSpec((int)heightConstraint, MeasureSpecMode.AtMost) : MeasureSpecFactory.MakeMeasureSpec(0, MeasureSpecMode.Unspecified); SizeRequest rawResult = visualElementRenderer.GetDesiredSize(widthMeasureSpec, heightMeasureSpec); if (rawResult.Minimum == Size.Zero) { rawResult.Minimum = rawResult.Request; } var result = new SizeRequest(new Size(context.FromPixels(rawResult.Request.Width), context.FromPixels(rawResult.Request.Height)), new Size(context.FromPixels(rawResult.Minimum.Width), context.FromPixels(rawResult.Minimum.Height))); if ((widthConstrained && result.Request.Width < widthConstraint) || (heightConstrained && result.Request.Height < heightConstraint)) { // Do a final exact measurement in case the native control needs to fill the container (visualElementRenderer as IViewRenderer)?.MeasureExactly(); } return(result); }
public override SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint) { var sizeRequest = base.GetDesiredSize(widthConstraint, heightConstraint); if (Math.Abs(sizeRequest.Request.Width) < 0.0) { var num = widthConstraint; if (widthConstraint <= 0) { num = (int)this.GetThemeAttributeDp(16843632); } else if (widthConstraint <= 0) { num = 100; } sizeRequest = new SizeRequest(new Size(num, sizeRequest.Request.Height), new Size(num, sizeRequest.Minimum.Height)); } return(sizeRequest); }
// an override of the size request to get the width and height square protected override SizeRequest OnSizeRequest(double widthConstraint, double heightConstraint) { // adding border to the padding to get the image inside the border if (padding < 0) { padding = base.Padding.Bottom; } if (SelectedBorderWidth < UnselectedBorderWidth) { base.Padding = (padding * 1) + (UnselectedBorderWidth * 1); } else { base.Padding = (padding * 1) + SelectedBorderWidth; } // now to actualy call the size of the control - first call the base size request then work out which dimension is higher(or exisits) then send that for both double fullsize = 0; SizeRequest mysize = base.OnSizeRequest(widthConstraint, heightConstraint); if (mysize.Request.Height > mysize.Request.Width || Double.IsInfinity(mysize.Request.Width)) { fullsize += mysize.Request.Height; } else { fullsize += mysize.Request.Width; } // and now for a default size if there is no images if (SelectedImage == null && UnselectedImage == null) { fullsize += 20; } // everythings been added up now to apply it return(new SizeRequest(new Size(fullsize, fullsize))); }
public override SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint) { SizeRequest sizeConstraint = base.GetDesiredSize(widthConstraint, heightConstraint); if (sizeConstraint.Request.Width == 0) { int width = widthConstraint; if (widthConstraint <= 0) { System.Diagnostics.Debug.WriteLine("Default values"); width = 100; } else if (widthConstraint <= 0) { width = 100; } sizeConstraint = new SizeRequest(new Size(width, sizeConstraint.Request.Height), new Size(width, sizeConstraint.Minimum.Height)); } return(sizeConstraint); }
/// <summary> /// Measure total size /// </summary> protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { MeasureChildren(widthConstraint, heightConstraint); Size actualSubMenuIconSize = new Size(); Thickness actualSubMenuIconMargin = new Thickness(); if (ItemsSource != null && ItemsSource.Count > 0 && IsSubMenuIconVisible && string.IsNullOrEmpty(SubMenuIconAssemblyName) == false && string.IsNullOrEmpty(SubMenuIconResourceKey) == false) { actualSubMenuIconSize = _subMenuIconSize; actualSubMenuIconMargin = SubMenuIconMargin; } SizeRequest size = base.OnMeasure(widthConstraint - _checkBoxSize.Width - actualSubMenuIconSize.Width, heightConstraint); Size s = new Size(); s.Width = size.Request.Width + _checkBoxSize.Width + actualSubMenuIconSize.Width + actualSubMenuIconMargin.HorizontalThickness; s.Height = size.Request.Height; return(new SizeRequest(s, s)); }
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint) { if (!_perfectSizeValid) { _perfectSize = base.GetDesiredSize(double.PositiveInfinity, double.PositiveInfinity); _perfectSize.Minimum = new Size(Math.Min(10, _perfectSize.Request.Width), _perfectSize.Request.Height); _perfectSizeValid = true; } var widthFits = widthConstraint >= _perfectSize.Request.Width; var heightFits = heightConstraint >= _perfectSize.Request.Height; if (widthFits && heightFits) return _perfectSize; var result = base.GetDesiredSize(widthConstraint, heightConstraint); var tinyWidth = Math.Min(10, result.Request.Width); result.Minimum = new Size(tinyWidth, result.Request.Height); if (widthFits || Element.LineBreakMode == LineBreakMode.NoWrap) return result; bool containerIsNotInfinitelyWide = !double.IsInfinity(widthConstraint); if (containerIsNotInfinitelyWide) { bool textCouldHaveWrapped = Element.LineBreakMode == LineBreakMode.WordWrap || Element.LineBreakMode == LineBreakMode.CharacterWrap; bool textExceedsContainer = result.Request.Width > widthConstraint; if (textExceedsContainer || textCouldHaveWrapped) { var expandedWidth = Math.Max(tinyWidth, widthConstraint); result.Request = new Size(expandedWidth, result.Request.Height); } } return result; }
public override SizeRequest GetDesiredSize(double widthConstraint, double heightConstraint) { var sizeConstraint = base.GetDesiredSize(widthConstraint, heightConstraint); if (sizeConstraint.Request.Width == 0) { var width = (int)Element.SizeRequest; if (widthConstraint <= 0) { System.Diagnostics.Debug.WriteLine("Default values"); width = DEFAULT_SIZE; } else if (widthConstraint <= 0) { width = DEFAULT_SIZE; } sizeConstraint = new SizeRequest(new Size(width, sizeConstraint.Request.Height), new Size(width, sizeConstraint.Minimum.Height)); } return(sizeConstraint); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { foreach (View child in Children) { if (!child.IsVisible) { continue; } SizeRequest sizeRequest = child.Measure(double.PositiveInfinity, double.PositiveInfinity, 0); Size minimum = sizeRequest.Minimum; Size request = sizeRequest.Request; _childHeight = Math.Max(minimum.Height, request.Height); _childWidth = Math.Max(minimum.Width, request.Width); } int columns = GetColumnsCount(Children.Count, widthConstraint, _childWidth); int rows = GetRowsCount(Children.Count, columns); Size size = new Size(columns * _childWidth, rows * _childHeight); return(new SizeRequest(size, size)); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { if (Device.RuntimePlatform != Device.iOS) { return(base.OnMeasure(widthConstraint, heightConstraint)); } var constraintSize = new Size(widthConstraint, heightConstraint); if (_measureCache.TryGetValue(constraintSize, out SizeRequest cachedSizeRequest)) { return(cachedSizeRequest); } SizeRequest desiredSizeRequest = ComputeDesiredSizeRequest(widthConstraint); if (desiredSizeRequest.Request.Width > 0 && desiredSizeRequest.Request.Height > 0) { _measureCache[constraintSize] = desiredSizeRequest; } return(desiredSizeRequest); }
internal override IList <IEnumerable <KeyValuePair <long, TResult> > > GetOrderedEnumerables(QueryOptions options) { var source = Parent.GetOrderedEnumerables(options); var sizeRequests = new SizeRequest[source.Count]; long deviation = 0; Barrier barrier = new Barrier(source.Count, delegate(Barrier b) { Array.Sort(sizeRequests, KeyComparator); for (int i = 0; i < b.ParticipantCount; ++i) { if (sizeRequests[i].Key == -1) { continue; } sizeRequests[i].Key = deviation; deviation += sizeRequests[i].Size; } }); return(source .Select((i, ind) => GetOrderedEnumerableInternal(i, sizeRequests, ind, barrier)) .ToList()); }
protected override void LayoutChildren(double x, double y, double width, double height) { foreach (Xamarin.Forms.View child in Children) { if (!child.IsVisible) { continue; } SizeRequest childSizeRequest = child.Measure(width, Double.PositiveInfinity, MeasureFlags.IncludeMargins); double xChild = x; double yChild = y; double childWidth = childSizeRequest.Request.Width; double childHeight = childSizeRequest.Request.Height; switch (child.HorizontalOptions.Alignment) { case LayoutAlignment.Start: break; case LayoutAlignment.Center: xChild += (width - childWidth) / 2; break; case LayoutAlignment.End: xChild += (width - childWidth); break; case LayoutAlignment.Fill: childWidth = width; break; } child.Layout(new Rectangle(xChild, yChild, childWidth, childHeight)); y += childHeight; } }
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec) { if (_child == null) { SetMeasuredDimension(0, 0); return; } VisualElement element = _child.Element; Context ctx = Context; var width = (int)ctx.FromPixels(MeasureSpecFactory.GetSize(widthMeasureSpec)); SizeRequest request = _child.Element.Measure(width, double.PositiveInfinity, MeasureFlags.IncludeMargins); Microsoft.Maui.Controls.Compatibility.Layout.LayoutChildIntoBoundingRegion(_child.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); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { SizeRequest desiredSize = base.OnMeasure(double.PositiveInfinity, double.PositiveInfinity); double desiredWidth = desiredSize.Request.Width; double desiredHeight = desiredSize.Request.Height; if (desiredWidth == 0 || desiredHeight == 0) { return(new SizeRequest(new Size(0, 0))); } if (double.IsPositiveInfinity(widthConstraint) && double.IsPositiveInfinity(heightConstraint)) { return(new SizeRequest(new Size(desiredWidth, desiredHeight))); } if (double.IsPositiveInfinity(widthConstraint)) { double factor = heightConstraint / desiredHeight; return(new SizeRequest(new Size(desiredWidth * factor, desiredHeight * factor))); } if (double.IsPositiveInfinity(heightConstraint)) { double factor = widthConstraint / desiredWidth; return(new SizeRequest(new Size(desiredWidth * factor, desiredHeight * factor))); } double fitsWidthRatio = widthConstraint / desiredWidth; double fitsHeightRatio = heightConstraint / desiredHeight; double ratioFactor = Math.Min(fitsWidthRatio, fitsHeightRatio); return(new SizeRequest(new Size(desiredWidth * ratioFactor, desiredHeight * ratioFactor))); }
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec) { if (Content == null) { SetMeasuredDimension(0, 0); return; } int pixelWidth = MeasureSpec.GetSize(widthMeasureSpec); int pixelHeight = MeasureSpec.GetSize(heightMeasureSpec); var width = MeasureSpec.GetMode(widthMeasureSpec) == MeasureSpecMode.Unspecified ? double.PositiveInfinity : Context.FromPixels(pixelWidth); var height = MeasureSpec.GetMode(heightMeasureSpec) == MeasureSpecMode.Unspecified ? double.PositiveInfinity : Context.FromPixels(pixelHeight); SizeRequest measure = Content.Element.Measure(width, height, MeasureFlags.IncludeMargins); // When we implement ItemSizingStrategy.MeasureFirstItem for Android, these next two clauses will need to // be updated to use the static width/height if (pixelWidth == 0) { pixelWidth = (int)Context.ToPixels(measure.Request.Width); } if (pixelHeight == 0) { pixelHeight = (int)Context.ToPixels(measure.Request.Height); } SetMeasuredDimension(pixelWidth, pixelHeight); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { var minimumSize = new Size(40, 40); Size request; double requestHeight = 0; double minimumHeight = 0; var itemsView = this as ITemplatedItemsView <Cell>; foreach (Cell cell in itemsView.TemplatedItems) { ViewCell vCell = cell as ViewCell; SizeRequest cellRequest = vCell.View.Measure(widthConstraint, heightConstraint); requestHeight += cellRequest.Request.Height; minimumHeight += cellRequest.Minimum.Height; } minimumHeight -= itemsView.TemplatedItems.Count; request = new Size(widthConstraint, requestHeight); return(new SizeRequest(request, minimumSize)); }
void ExpandLastAutoRowIfNeeded(Grid grid, double height, bool expandToRequest) { for (var index = 0; index < grid.InternalChildren.Count; index++) { Element element = grid.InternalChildren[index]; var child = (View)element; if (!child.IsVisible) { continue; } RowDefinition row = GetLastAutoRow(child); if (row == null) { continue; } double assignedHeight = GetAssignedRowHeight(child); var unassignedHeight = GetUnassignedHeight(height, grid.RowSpacing); double h = double.IsPositiveInfinity(height) ? double.PositiveInfinity : assignedHeight + unassignedHeight; var acw = GetAssignedColumnWidth(child); SizeRequest sizeRequest = child.Measure(acw, h, MeasureFlags.IncludeMargins); double requiredHeight = expandToRequest ? sizeRequest.Request.Height : sizeRequest.Request.Height <= h ? sizeRequest.Request.Height : sizeRequest.Minimum.Height; double deltaHeight = requiredHeight - assignedHeight - (GetRowSpan(child) - 1) * grid.RowSpacing; if (deltaHeight > 0) { row.ActualHeight += deltaHeight; } } }
void CalculateNaiveLayout(LayoutInformation layout, StackOrientation orientation, double x, double y, double widthConstraint, double heightConstraint) { layout.CompressionSpace = 0; double xOffset = x; double yOffset = y; double boundsWidth = 0; double boundsHeight = 0; double minimumWidth = 0; double minimumHeight = 0; double spacing = Spacing; if (orientation == StackOrientation.Vertical) { View expander = null; for (var i = 0; i < LogicalChildrenInternal.Count; i++) { var child = (View)LogicalChildrenInternal[i]; if (!child.IsVisible) { continue; } if (child.VerticalOptions.Expands) { layout.Expanders++; if (expander != null) { // we have multiple expanders, make sure previous expanders are reset to not be fixed because they no logner are ComputeConstraintForView(child, false); } expander = child; } SizeRequest request = child.Measure(widthConstraint, double.PositiveInfinity, MeasureFlags.IncludeMargins); var bounds = new Rectangle(x, yOffset, request.Request.Width, request.Request.Height); layout.Plots[i] = bounds; layout.Requests[i] = request; layout.CompressionSpace += Math.Max(0, request.Request.Height - request.Minimum.Height); yOffset = bounds.Bottom + spacing; boundsWidth = Math.Max(boundsWidth, request.Request.Width); boundsHeight = bounds.Bottom - y; minimumHeight += request.Minimum.Height + spacing; minimumWidth = Math.Max(minimumWidth, request.Minimum.Width); } minimumHeight -= spacing; if (expander != null) { ComputeConstraintForView(expander, layout.Expanders == 1); // warning : slightly obtuse, but we either need to setup the expander or clear the last one } } else { View expander = null; for (var i = 0; i < LogicalChildrenInternal.Count; i++) { var child = (View)LogicalChildrenInternal[i]; if (!child.IsVisible) { continue; } if (child.HorizontalOptions.Expands) { layout.Expanders++; if (expander != null) { ComputeConstraintForView(child, false); } expander = child; } SizeRequest request = child.Measure(double.PositiveInfinity, heightConstraint, MeasureFlags.IncludeMargins); var bounds = new Rectangle(xOffset, y, request.Request.Width, request.Request.Height); layout.Plots[i] = bounds; layout.Requests[i] = request; layout.CompressionSpace += Math.Max(0, request.Request.Width - request.Minimum.Width); xOffset = bounds.Right + spacing; boundsWidth = bounds.Right - x; boundsHeight = Math.Max(boundsHeight, request.Request.Height); minimumWidth += request.Minimum.Width + spacing; minimumHeight = Math.Max(minimumHeight, request.Minimum.Height); } minimumWidth -= spacing; if (expander != null) { ComputeConstraintForView(expander, layout.Expanders == 1); } } layout.Bounds = new Rectangle(x, y, boundsWidth, boundsHeight); layout.MinimumSize = new Size(minimumWidth, minimumHeight); }
protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint) { SizeRequest desiredSize = base.OnMeasure(double.PositiveInfinity, double.PositiveInfinity); return(ImageElement.Measure(this, desiredSize, widthConstraint, heightConstraint)); }
public virtual SizeRequest GetSizeRequest(double widthConstraint, double heightConstraint) { SizeRequest cachedResult; var constraintSize = new Size(widthConstraint, heightConstraint); if (_measureCache.TryGetValue(constraintSize, out cachedResult)) { return cachedResult; } double widthRequest = WidthRequest; double heightRequest = HeightRequest; if (widthRequest >= 0) widthConstraint = Math.Min(widthConstraint, widthRequest); if (heightRequest >= 0) heightConstraint = Math.Min(heightConstraint, heightRequest); SizeRequest result = OnMeasure(widthConstraint, heightConstraint); bool hasMinimum = result.Minimum != result.Request; Size request = result.Request; Size minimum = result.Minimum; if (heightRequest != -1) { request.Height = heightRequest; if (!hasMinimum) minimum.Height = heightRequest; } if (widthRequest != -1) { request.Width = widthRequest; if (!hasMinimum) minimum.Width = widthRequest; } double minimumHeightRequest = MinimumHeightRequest; double minimumWidthRequest = MinimumWidthRequest; if (minimumHeightRequest != -1) minimum.Height = minimumHeightRequest; if (minimumWidthRequest != -1) minimum.Width = minimumWidthRequest; minimum.Height = Math.Min(request.Height, minimum.Height); minimum.Width = Math.Min(request.Width, minimum.Width); var r = new SizeRequest(request, minimum); if (r.Request.Width > 0 && r.Request.Height > 0) { _measureCache[constraintSize] = r; } return r; }
public SizeRequest Measure(ISet<State> states, Size availableSize, SizeRequest contentSize) { var minWidth = contentSize.Minimum.Width + Math.Max(Stretch.Horizontal.Margin, Content.Horizontal.Margin); var minHeight = contentSize.Minimum.Height + Math.Max(Stretch.Vertical.Margin, Content.Vertical.Margin); if (double.IsNaN(availableSize.Width) || availableSize.Width > Width) availableSize.Width = Math.Max(Width, minWidth); if (double.IsNaN(availableSize.Height) || availableSize.Height > Height) availableSize.Height = Math.Max(Height, minHeight); return new SizeRequest(availableSize, new Size(minWidth, minHeight)); }
public SizeRequest Measure(ISet<State> states, Size availableSize, SizeRequest contentSize) { var image = FromState(states); if (image == null) return default(SizeRequest); return image.Measure(states, availableSize, contentSize); }
static double GetMaxWidth(double width, SizeRequest size) { return Math.Max(size.Request.Width, width); }
SizeRequest IPlatform.GetNativeSize(VisualElement view, double widthConstraint, double heightConstraint) { Performance.Start(); // FIXME: potential crash IVisualElementRenderer viewRenderer = Android.Platform.GetRenderer(view); // negative numbers have special meanings to android they don't to us widthConstraint = widthConstraint <= -1 ? double.PositiveInfinity : _context.ToPixels(widthConstraint); heightConstraint = heightConstraint <= -1 ? double.PositiveInfinity : _context.ToPixels(heightConstraint); int width = !double.IsPositiveInfinity(widthConstraint) ? MeasureSpecFactory.MakeMeasureSpec((int)widthConstraint, MeasureSpecMode.AtMost) : MeasureSpecFactory.MakeMeasureSpec(0, MeasureSpecMode.Unspecified); int height = !double.IsPositiveInfinity(heightConstraint) ? MeasureSpecFactory.MakeMeasureSpec((int)heightConstraint, MeasureSpecMode.AtMost) : MeasureSpecFactory.MakeMeasureSpec(0, MeasureSpecMode.Unspecified); SizeRequest rawResult = viewRenderer.GetDesiredSize(width, height); if (rawResult.Minimum == Size.Zero) rawResult.Minimum = rawResult.Request; var result = new SizeRequest(new Size(_context.FromPixels(rawResult.Request.Width), _context.FromPixels(rawResult.Request.Height)), new Size(_context.FromPixels(rawResult.Minimum.Width), _context.FromPixels(rawResult.Minimum.Height))); Performance.Stop(); return result; }
static double GetMaxHeight(double height, SizeRequest size) { return Math.Max(size.Request.Height, height); }
public static void RecalculateSpanPositions(this TextView textView, Label element, SpannableString spannableString, SizeRequest finalSize) { if (element?.FormattedText?.Spans == null || element.FormattedText.Spans.Count == 0) { return; } var labelWidth = finalSize.Request.Width; if (labelWidth <= 0 || finalSize.Request.Height <= 0) { return; } if (spannableString == null || spannableString.IsDisposed()) { return; } var layout = textView.Layout; if (layout == null) { return; } int next = 0; int count = 0; IList <int> totalLineHeights = new List <int>(); for (int i = 0; i < spannableString.Length(); i = next) { var type = Java.Lang.Class.FromType(typeof(Java.Lang.Object)); var span = element.FormattedText.Spans[count]; count++; if (string.IsNullOrEmpty(span.Text)) { continue; } // find the next span next = spannableString.NextSpanTransition(i, spannableString.Length(), type); // get all spans in the range - Android can have overlapping spans var spans = spannableString.GetSpans(i, next, type); var startSpan = spans[0]; var endSpan = spans[spans.Length - 1]; var startSpanOffset = spannableString.GetSpanStart(startSpan); var endSpanOffset = spannableString.GetSpanEnd(endSpan); var thisLine = layout.GetLineForOffset(endSpanOffset); var lineStart = layout.GetLineStart(thisLine); var lineEnd = layout.GetLineEnd(thisLine); //If this is true, endSpanOffset has the value for another line that belong to the next span and not it self. //So it should be rearranged to value not pass the lineEnd. if (endSpanOffset > (lineEnd - lineStart)) { endSpanOffset = lineEnd; } var startX = layout.GetPrimaryHorizontal(startSpanOffset); var endX = layout.GetPrimaryHorizontal(endSpanOffset); var startLine = layout.GetLineForOffset(startSpanOffset); var endLine = layout.GetLineForOffset(endSpanOffset); double[] lineHeights = new double[endLine - startLine + 1]; // calculate all the different line heights for (var lineCount = startLine; lineCount <= endLine; lineCount++) { var lineHeight = layout.GetLineBottom(lineCount) - layout.GetLineTop(lineCount); lineHeights[lineCount - startLine] = lineHeight; if (totalLineHeights.Count <= lineCount) { totalLineHeights.Add(lineHeight); } } var yaxis = 0.0; for (var line = startLine; line > 0; line--) { yaxis += totalLineHeights[line]; } ((ISpatialElement)span).Region = Region.FromLines(lineHeights, labelWidth, startX, endX, yaxis).Inflate(10); } }
public SizeRequest Measure(ISet<State> states, Size availableSize, SizeRequest contentSize) { return new SizeRequest(new Size(_texture.Width, _texture.Height), default(Size)); }