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));
}
