private int MeasureWidth(int measureSpec)
{
int result;
MeasureSpecMode specMode = MeasureSpec.GetMode(measureSpec);
int specSize = MeasureSpec.GetSize(measureSpec);
if (specMode == MeasureSpecMode.Exactly)
{
// The parent has determined an exact size for the child.
result = specSize;
}
else if (specMode == MeasureSpecMode.AtMost)
{
// The child can be as large as it wants up to the specified size.
result = specSize;
}
else
{
// The parent has not imposed any constraint on the child.
result = _canvasSize;
}
return(result);
}
private int MeasureHeight(int measureSpecHeight)
{
int result;
MeasureSpecMode specMode = MeasureSpec.GetMode(measureSpecHeight);
int specSize = MeasureSpec.GetSize(measureSpecHeight);
if (specMode == MeasureSpecMode.Exactly)
{
// We were told how big to be
result = specSize;
}
else if (specMode == MeasureSpecMode.AtMost)
{
// The child can be as large as it wants up to the specified size.
result = specSize;
}
else
{
// Measure the text (beware: ascent is a negative number)
result = _canvasSize;
}
return(result + 2);
}
/**
* Determines the width of this view
* @param measureSpec A measureSpec packed into an int
* @return The width of the view, honoring constraints from measureSpec
*/
private int measureWidth(int measureSpec)
{
int result = 0;
MeasureSpecMode specMode = MeasureSpec.GetMode(measureSpec);
int specSize = MeasureSpec.GetSize(measureSpec);
if (specMode == MeasureSpecMode.Exactly)
{
// We were told how big to be
result = specSize;
}
else
{
// Measure the text
result = IMAGE_WIDTH + MAX_TEXT_WIDTH + TOAST_HEIGHT;
if (specMode == MeasureSpecMode.AtMost)
{
// Respect AT_MOST value if that was what is called for by measureSpec
result = Math.Min(result, specSize);
}
}
return(result);
}
private int FindSize(MeasureSpecMode modeSize, int controlMaxSize, int contentSize)
{
int realControlLength;
switch (modeSize)
{
case MeasureSpecMode.Unspecified:
realControlLength = contentSize;
break;
case MeasureSpecMode.AtMost:
realControlLength = Math.Min(contentSize, controlMaxSize);
break;
case MeasureSpecMode.Exactly:
realControlLength = controlMaxSize;
break;
default:
realControlLength = contentSize;
break;
}
return(realControlLength);
}
protected override (float measuredWidth, float measuredHeight) OnMesure(float widthSpec, float heightSpec, MeasureSpecMode mode)
{
for (int i = 0; i < Children.Count; i++)
{
var child = Children[i];
child.Mesure(widthSpec, heightSpec, MeasureSpecMode.AtMost);
if (child.HorizontalAligment == HorizontalAligment.Stretch)
{
child.Mesure(widthSpec, child.GetValue <float>(nameof(child.CalculatedHeight), ReactiveObject.LAYOUT_VALUE), MeasureSpecMode.Exactly);
}
else if (child.Width != (int)WidthOptions.Auto)
{
child.Mesure(child.Width, child.GetValue <float>(nameof(child.CalculatedHeight), ReactiveObject.LAYOUT_VALUE), MeasureSpecMode.Exactly);
}
if (child.VerticalAligment == VerticalAligment.Stretch)
{
child.Mesure(child.GetValue <float>(nameof(child.CalculatedWidth), ReactiveObject.LAYOUT_VALUE), heightSpec, MeasureSpecMode.Exactly);
}
else if (child.Height != (int)HeightOptions.Auto)
{
child.Mesure(child.GetValue <float>(nameof(child.CalculatedWidth), ReactiveObject.LAYOUT_VALUE), child.Height, MeasureSpecMode.Exactly);
}
}
return(base.OnMesure(widthSpec, heightSpec, MeasureSpecMode.Exactly));//(widthSpec, heightSpec);
}
int MakeMeasureSpec(MeasureSpecMode mode, int size)
{
return(size + (int)mode);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int width = 0;
int height = 0;
MeasureSpecMode widthMode = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode heightMode = MeasureSpec.GetMode(heightMeasureSpec);
int widthAllowed = MeasureSpec.GetSize(widthMeasureSpec);
int heightAllowed = MeasureSpec.GetSize(heightMeasureSpec);
//Log.d("color-picker-view", "widthMode: " + modeToString(widthMode) + " heightMode: " + modeToString(heightMode) + " widthAllowed: " + widthAllowed + " heightAllowed: " + heightAllowed);
if (widthMode == MeasureSpecMode.Exactly || heightMode == MeasureSpecMode.Exactly)
{
//A exact value has been set in either direction, we need to stay within this size.
if (widthMode == MeasureSpecMode.Exactly && heightMode != MeasureSpecMode.Exactly)
{
//The with has been specified exactly, we need to adopt the height to fit.
int h = (int)(widthAllowed - _panelSpacing - _huePanelWidth);
if (_mShowAlphaPanel)
{
h += (int)(_panelSpacing + _alphaPanelHeight);
}
height = h > heightAllowed ? heightAllowed : h;
width = widthAllowed;
}
else if (heightMode == MeasureSpecMode.Exactly && widthMode != MeasureSpecMode.Exactly)
{
//The height has been specified exactly, we need to stay within this height and adopt the width.
int w = (int)(heightAllowed + _panelSpacing + _huePanelWidth);
if (_mShowAlphaPanel)
{
w -= (int)(_panelSpacing - _alphaPanelHeight);
}
width = w > widthAllowed ? widthAllowed : w;
height = heightAllowed;
}
else
{
//If we get here the dev has set the width and height to exact sizes. For example match_parent or 300dp.
//This will mean that the sat/val panel will not be square but it doesn't matter. It will work anyway.
//In all other senarios our goal is to make that panel square.
//We set the sizes to exactly what we were told.
width = widthAllowed;
height = heightAllowed;
}
}
else
{
//If no exact size has been set we try to make our view as big as possible
//within the allowed space.
//Calculate the needed with to layout the view based on the allowed height.
int widthNeeded = (int)(heightAllowed + _panelSpacing + _huePanelWidth);
//Calculate the needed height to layout the view based on the allowed width.
int heightNeeded = (int)(widthAllowed - _panelSpacing - _huePanelWidth);
if (_mShowAlphaPanel)
{
widthNeeded -= (int)(_panelSpacing + _alphaPanelHeight);
heightNeeded += (int)(_panelSpacing + _alphaPanelHeight);
}
if (widthNeeded <= widthAllowed)
{
width = widthNeeded;
height = heightAllowed;
}
else if (heightNeeded <= heightAllowed)
{
height = heightNeeded;
width = widthAllowed;
}
}
//Log.d("mColorPicker", " Size: " + Width + "x" + Height);
SetMeasuredDimension(width, height);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
int sizeWidth = MeasureSpec.GetSize(widthMeasureSpec) - PaddingLeft - PaddingRight;
int sizeHeight = MeasureSpec.GetSize(heightMeasureSpec);
MeasureSpecMode modeWidth = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode modeHeight = MeasureSpec.GetMode(heightMeasureSpec);
int width = 0;
int height = PaddingTop + PaddingBottom;
int lineWidth = 0;
int lineHeight = 0;
int childCount = ChildCount;
for (int i = 0; i < childCount; i++)
{
View child = GetChildAt(i);
bool lastChild = i == childCount - 1;
if (child.Visibility == ViewStates.Gone)
{
if (lastChild)
{
width = Math.Max(width, lineWidth);
height += lineHeight;
}
continue;
}
MeasureChildWithMargins(child, widthMeasureSpec, lineWidth, heightMeasureSpec, height);
CustomLayoutParams lp = (CustomLayoutParams)child.LayoutParameters;
MeasureSpecMode childWidthMode = MeasureSpecMode.AtMost;
int childWidthSize = sizeWidth;
MeasureSpecMode childHeightMode = MeasureSpecMode.AtMost;
int childHeightSize = sizeHeight;
if (lp.Width == LayoutParams.MatchParent)
{
childWidthMode = MeasureSpecMode.Exactly;
childWidthSize -= lp.LeftMargin + lp.RightMargin;
}
else if (lp.Width >= 0)
{
childWidthMode = MeasureSpecMode.Exactly;
childWidthSize = lp.Width;
}
if (lp.Height >= 0)
{
childHeightMode = MeasureSpecMode.Exactly;
childHeightSize = lp.Height;
}
else if (modeHeight == MeasureSpecMode.Unspecified)
{
childHeightMode = MeasureSpecMode.Unspecified;
childHeightSize = 0;
}
child.Measure(MeasureSpec.MakeMeasureSpec(childWidthSize, childWidthMode), MeasureSpec.MakeMeasureSpec(childHeightSize, childHeightMode));
int childWidth = child.MeasuredWidth + lp.LeftMargin + lp.RightMargin;
if (lineWidth + childWidth > sizeWidth)
{
width = Math.Max(width, lineWidth);
lineWidth = childWidth;
height += lineHeight;
lineHeight = child.MeasuredHeight + lp.TopMargin + lp.BottomMargin;
}
else
{
lineWidth += childWidth;
lineHeight = Math.Max(lineHeight, child.MeasuredHeight + lp.TopMargin + lp.BottomMargin);
}
if (lastChild)
{
width = Math.Max(width, lineWidth);
height += lineHeight;
}
}
width += PaddingLeft + PaddingRight;
SetMeasuredDimension((modeWidth == MeasureSpecMode.Exactly) ? sizeWidth : width, (modeHeight == MeasureSpecMode.Exactly) ? sizeHeight : height);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int finalWidth = 0;
int finalHeight = 0;
MeasureSpecMode widthMode = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode heightMode = MeasureSpec.GetMode(heightMeasureSpec);
int widthAllowed = (int)MeasureSpec.GetSize(widthMeasureSpec);
int heightAllowed = (int)MeasureSpec.GetSize(heightMeasureSpec);
//Log.d("color-picker-view", "widthMode: " + modeToString(widthMode) + " heightMode: " + modeToString(heightMode) + " widthAllowed: " + widthAllowed + " heightAllowed: " + heightAllowed);
if (widthMode == MeasureSpecMode.Exactly || heightMode == MeasureSpecMode.Exactly)
{
//A exact value has been set in either direction, we need to stay within this size.
if (widthMode == MeasureSpecMode.Exactly && heightMode != MeasureSpecMode.Exactly)
{
//The with has been specified exactly, we need to adopt the height to fit.
int h = (int)(widthAllowed - PANEL_SPACING - HUE_PANEL_WIDTH);
if (mShowAlphaPanel)
{
h += (int)(PANEL_SPACING + ALPHA_PANEL_HEIGHT);
}
if (h > heightAllowed)
{
//We can't fit the view in this container, set the size to whatever was allowed.
finalHeight = heightAllowed;
}
else
{
finalHeight = h;
}
finalWidth = widthAllowed;
}
else if (heightMode == MeasureSpecMode.Exactly && widthMode != MeasureSpecMode.Exactly)
{
//The height has been specified exactly, we need to stay within this height and adopt the width.
int w = (int)(heightAllowed + PANEL_SPACING + HUE_PANEL_WIDTH);
if (mShowAlphaPanel)
{
w -= (int)(PANEL_SPACING - ALPHA_PANEL_HEIGHT);
}
if (w > widthAllowed)
{
//we can't fit within this container, set the size to whatever was allowed.
finalWidth = widthAllowed;
}
else
{
finalWidth = w;
}
finalHeight = heightAllowed;
}
else
{
//If we get here the dev has set the width and height to exact sizes. For example match_parent or 300dp.
//This will mean that the sat/val panel will not be square but it doesn't matter. It will work anyway.
//In all other senarios our goal is to make that panel square.
//We set the sizes to exactly what we were told.
finalWidth = widthAllowed;
finalHeight = heightAllowed;
}
}
else
{
//If no exact size has been set we try to make our view as big as possible
//within the allowed space.
//Calculate the needed with to layout the view based on the allowed height.
int widthNeeded = (int)(heightAllowed + PANEL_SPACING + HUE_PANEL_WIDTH);
//Calculate the needed height to layout the view based on the allowed width.
int heightNeeded = (int)(widthAllowed - PANEL_SPACING - HUE_PANEL_WIDTH);
if (mShowAlphaPanel)
{
widthNeeded -= (int)(PANEL_SPACING + ALPHA_PANEL_HEIGHT);
heightNeeded += (int)(PANEL_SPACING + ALPHA_PANEL_HEIGHT);
}
if (widthNeeded <= widthAllowed)
{
finalWidth = widthNeeded;
finalHeight = heightAllowed;
}
else if (heightNeeded <= heightAllowed)
{
finalHeight = heightNeeded;
finalWidth = widthAllowed;
}
}
//Log.d("mColorPicker", "Final Size: " + finalWidth + "x" + finalHeight);
SetMeasuredDimension(finalWidth, finalHeight);
}
public static int MakeMeasureSpec(int size, MeasureSpecMode mode)
{
return((size & ~MODE_MASK) | ((int)mode & MODE_MASK));
}
public static int MakeMeasureSpec(int size, MeasureSpecMode mode) {
return size + (int)mode;
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
//Log.i("@@@@", "onMeasure(" + MeasureSpec.toString(widthMeasureSpec) + ", "
// + MeasureSpec.toString(heightMeasureSpec) + ")");
int width = GetDefaultSize(mVideoWidth, widthMeasureSpec);
int height = GetDefaultSize(mVideoHeight, heightMeasureSpec);
if (mVideoWidth > 0 && mVideoHeight > 0)
{
MeasureSpecMode widthSpecMode = MeasureSpec.GetMode(widthMeasureSpec);
int widthSpecSize = MeasureSpec.GetSize(widthMeasureSpec);
MeasureSpecMode heightSpecMode = MeasureSpec.GetMode(heightMeasureSpec);
int heightSpecSize = MeasureSpec.GetSize(heightMeasureSpec);
if (widthSpecMode == MeasureSpecMode.Exactly && heightSpecMode == MeasureSpecMode.Exactly)
{
// the size is fixed
width = widthSpecSize;
height = heightSpecSize;
// for compatibility, we adjust size based on aspect ratio
if (mVideoWidth * height < width * mVideoHeight)
{
//Log.i("@@@", "image too wide, correcting");
width = height * mVideoWidth / mVideoHeight;
}
else if (mVideoWidth * height > width * mVideoHeight)
{
//Log.i("@@@", "image too tall, correcting");
height = width * mVideoHeight / mVideoWidth;
}
}
else if (widthSpecMode == MeasureSpecMode.Exactly)
{
// only the width is fixed, adjust the height to match aspect ratio if possible
width = widthSpecSize;
height = width * mVideoHeight / mVideoWidth;
if (heightSpecMode == MeasureSpecMode.AtMost && height > heightSpecSize)
{
// couldn't match aspect ratio within the constraints
height = heightSpecSize;
}
}
else if (heightSpecMode == MeasureSpecMode.Exactly)
{
// only the height is fixed, adjust the width to match aspect ratio if possible
height = heightSpecSize;
width = height * mVideoWidth / mVideoHeight;
if (widthSpecMode == MeasureSpecMode.AtMost && width > widthSpecSize)
{
// couldn't match aspect ratio within the constraints
width = widthSpecSize;
}
}
else
{
// neither the width nor the height are fixed, try to use actual video size
width = mVideoWidth;
height = mVideoHeight;
if (heightSpecMode == MeasureSpecMode.AtMost && height > heightSpecSize)
{
// too tall, decrease both width and height
height = heightSpecSize;
width = height * mVideoWidth / mVideoHeight;
}
if (widthSpecMode == MeasureSpecMode.AtMost && width > widthSpecSize)
{
// too wide, decrease both width and height
width = widthSpecSize;
height = width * mVideoHeight / mVideoWidth;
}
}
}
else
{
// no size yet, just adopt the given spec sizes
}
SetMeasuredDimension(width, height);
}
private int ChooseHeight(MeasureSpecMode mode, int size)
{
if (mode == MeasureSpecMode.AtMost || mode == MeasureSpecMode.Exactly)
{
return size;
}
return GetPrefferedHeight();
}
private void MeasureFirstStageViews(int width, MeasureSpecMode widthMode, int height, MeasureSpecMode heightMode)
{
// measure all children that we can measure at this moment (p-a, p-p, a-a, p-unspec, a-unspec)
foreach (var viewInfo in _viewsMeasureInfos.Values)
{
var child = viewInfo.View;
bool canMeasureHeight = heightMode == MeasureSpecMode.Unspecified ||
viewInfo.IsInAutoRow ||
viewInfo.IsOnlyInPixelRows;
bool canMeasureWidth = widthMode == MeasureSpecMode.Unspecified ||
viewInfo.IsInAutoColumn ||
viewInfo.IsOnlyInPixelColumns;
if (!canMeasureHeight || !canMeasureWidth)
{
continue;
}
var childWidthMeasureSpec = MeasureSpec.MakeMeasureSpec(width,
widthMode == MeasureSpecMode.Unspecified ? widthMode : MeasureSpecMode.AtMost);
var childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(height,
heightMode == MeasureSpecMode.Unspecified ? heightMode : MeasureSpecMode.AtMost);
child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
viewInfo.IsMeasured = true;
var dynamicWidth = Math.Max(0, child.MeasuredWidth - viewInfo.StaticWidth);
var dynamicHeight = Math.Max(0, child.MeasuredHeight - viewInfo.StaticHeight);
if (viewInfo.IsInAutoRow)
{
if (!(viewInfo.FirstAutoRow.IsMeasured && viewInfo.FirstAutoRow.Length > dynamicHeight))
{
viewInfo.FirstAutoRow.SetLength(dynamicHeight);
}
}
else if (viewInfo.IsInStarRow && heightMode == MeasureSpecMode.Unspecified)
{
foreach (var rowInfo in viewInfo.AssociatedRows)
{
if (rowInfo.Definition.Length.IsStar)
{
var dynamicStarHeight = dynamicHeight * (rowInfo.Definition.Length.Value / viewInfo.HeightStarSum);
if (!(rowInfo.IsMeasured && rowInfo.Length > dynamicStarHeight))
{
rowInfo.SetLength(dynamicStarHeight);
}
}
}
}
if (viewInfo.IsInAutoColumn)
{
if (!(viewInfo.FirstAutoColumn.IsMeasured && viewInfo.FirstAutoColumn.Length > dynamicWidth))
{
viewInfo.FirstAutoColumn.SetLength(dynamicWidth);
}
}
else if (viewInfo.IsInStarColumn && heightMode == MeasureSpecMode.Unspecified)
{
foreach (var columnInfo in viewInfo.AssociatedColumns)
{
if (columnInfo.Definition.Length.IsStar)
{
var dynamicStarWidth = dynamicWidth * (columnInfo.Definition.Length.Value / viewInfo.WidthStarSum);
if (!(columnInfo.IsMeasured && columnInfo.Length > dynamicStarWidth))
{
columnInfo.SetLength(dynamicStarWidth);
}
}
}
}
}
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int sizeWidth = MeasureSpec.GetSize(widthMeasureSpec) - this.PaddingRight - this.PaddingLeft;
int sizeHeight = MeasureSpec.GetSize(heightMeasureSpec) - this.PaddingTop - this.PaddingBottom;
MeasureSpecMode modeWidth = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode modeHeight = MeasureSpec.GetMode(heightMeasureSpec);
int controlMaxLength = this.config.Orientation == HORIZONTAL ? sizeWidth : sizeHeight;
int controlMaxThickness = this.config.Orientation == HORIZONTAL ? sizeHeight : sizeWidth;
MeasureSpecMode modeLength = this.config.Orientation == HORIZONTAL ? modeWidth : modeHeight;
MeasureSpecMode modeThickness = this.config.Orientation == HORIZONTAL ? modeHeight : modeWidth;
lines.Clear();
LineDefinition currentLine = new LineDefinition(controlMaxLength, config);
lines.Add(currentLine);
int count = this.ChildCount;
for (int i = 0; i < count; i++)
{
View child = this.GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
CustomLayoutParams lp = (CustomLayoutParams)child.LayoutParameters;
child.Measure(GetChildMeasureSpec(widthMeasureSpec, this.PaddingLeft + this.PaddingRight, lp.Width), GetChildMeasureSpec(heightMeasureSpec, this.PaddingTop + this.PaddingBottom, lp.Height));
lp.ClearCalculatedFields(this.config.Orientation);
if (this.config.Orientation == FlowLayout.HORIZONTAL)
{
lp.Length = child.MeasuredWidth;
lp.Thickness = child.MeasuredHeight;
}
else
{
lp.Length = child.MeasuredHeight;
lp.Thickness = child.MeasuredWidth;
}
bool newLine = lp.newLine || (modeLength != MeasureSpecMode.Unspecified && !currentLine.CanFit(child));
if (newLine)
{
currentLine = new LineDefinition(controlMaxLength, config);
if (this.config.Orientation == VERTICAL && this.config.Direction == LAYOUT_DIRECTION_RTL)
{
lines.Insert(0, currentLine);
}
else
{
lines.Add(currentLine);
}
}
if (this.config.Orientation == HORIZONTAL && this.config.Direction == LAYOUT_DIRECTION_RTL)
{
currentLine.AddView(0, child);
}
else
{
currentLine.AddView(child);
}
}
this.CalculateLinesAndChildPosition(lines);
int contentLength = 0;
foreach (LineDefinition l in lines)
{
contentLength = Math.Max(contentLength, l.LineLength);
}
int contentThickness = currentLine.LineStartThickness + currentLine.LineThickness;
int realControlLength = this.FindSize(modeLength, controlMaxLength, contentLength);
int realControlThickness = this.FindSize(modeHeight, controlMaxThickness, contentThickness);
this.ApplyGravityToLines(lines, realControlLength, realControlThickness);
foreach (LineDefinition line in lines)
{
this.ApplyGravityToLine(line);
this.ApplyPositionsToViews(line);
}
/* need to take padding into account */
int totalControlWidth = this.PaddingLeft + this.PaddingRight;
int totalControlHeight = this.PaddingBottom + this.PaddingTop;
if (this.config.Orientation == HORIZONTAL)
{
totalControlWidth += contentLength;
totalControlHeight += contentThickness;
}
else
{
totalControlWidth += contentThickness;
totalControlHeight += contentLength;
}
this.SetMeasuredDimension(ResolveSize(totalControlWidth, widthMeasureSpec), ResolveSize(totalControlHeight, heightMeasureSpec));
}
private void MeasureFirstStageViews(int width, MeasureSpecMode widthMode, int height, MeasureSpecMode heightMode)
{
// measure all children that we can measure at this moment (p-a, p-p, a-a, p-unspec, a-unspec)
foreach(var viewInfo in _viewsMeasureInfos.Values)
{
var child = viewInfo.View;
bool canMeasureHeight = heightMode == MeasureSpecMode.Unspecified
|| viewInfo.IsInAutoRow
|| viewInfo.IsOnlyInPixelRows;
bool canMeasureWidth = widthMode == MeasureSpecMode.Unspecified
|| viewInfo.IsInAutoColumn
|| viewInfo.IsOnlyInPixelColumns;
if(!canMeasureHeight || !canMeasureWidth)
{
continue;
}
var childWidthMeasureSpec = MeasureSpec.MakeMeasureSpec(width,
widthMode == MeasureSpecMode.Unspecified ? widthMode : MeasureSpecMode.AtMost);
var childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(height,
heightMode == MeasureSpecMode.Unspecified ? heightMode : MeasureSpecMode.AtMost);
child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
viewInfo.IsMeasured = true;
var dynamicWidth = Math.Max(0, child.MeasuredWidth - viewInfo.StaticWidth);
var dynamicHeight = Math.Max(0, child.MeasuredHeight - viewInfo.StaticHeight);
if(viewInfo.IsInAutoRow)
{
if(!(viewInfo.FirstAutoRow.IsMeasured && viewInfo.FirstAutoRow.Length > dynamicHeight))
{
viewInfo.FirstAutoRow.SetLength(dynamicHeight);
}
}
else if(viewInfo.IsInStarRow && heightMode == MeasureSpecMode.Unspecified)
{
foreach(var rowInfo in viewInfo.AssociatedRows)
{
if(rowInfo.Definition.Length.IsStar)
{
var dynamicStarHeight = dynamicHeight * (rowInfo.Definition.Length.Value / viewInfo.HeightStarSum);
if(!(rowInfo.IsMeasured && rowInfo.Length > dynamicStarHeight))
{
rowInfo.SetLength(dynamicStarHeight);
}
}
}
}
if(viewInfo.IsInAutoColumn)
{
if(!(viewInfo.FirstAutoColumn.IsMeasured && viewInfo.FirstAutoColumn.Length > dynamicWidth))
{
viewInfo.FirstAutoColumn.SetLength(dynamicWidth);
}
}
else if(viewInfo.IsInStarColumn && heightMode == MeasureSpecMode.Unspecified)
{
foreach(var columnInfo in viewInfo.AssociatedColumns)
{
if(columnInfo.Definition.Length.IsStar)
{
var dynamicStarWidth = dynamicWidth * (columnInfo.Definition.Length.Value / viewInfo.WidthStarSum);
if(!(columnInfo.IsMeasured && columnInfo.Length > dynamicStarWidth))
{
columnInfo.SetLength(dynamicStarWidth);
}
}
}
}
}
}
/// <summary>
/// Based on internal class Xamarin.Forms.Platform.Android.MeasureSpecFactory
/// </summary>
/// <param name="size">The size.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
private static int MakeMeasureSpec(int size, MeasureSpecMode mode)
{
return(( int )(size + mode));
}
public static int MakeMeasureSpec(int size, MeasureSpecMode mode) => size + (int)mode;
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
MeasureSpecMode widthMode = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode heightMode = MeasureSpec.GetMode(heightMeasureSpec);
int widthSize = MeasureSpec.GetSize(widthMeasureSpec);
int heightSize = MeasureSpec.GetSize(heightMeasureSpec);
MeasureChildren(widthMeasureSpec, heightMeasureSpec);
int width = 0;
int height = 0;
int row = 0; // The row counter.
int rowWidth = 0; // Calc the current row width.
int rowMaxHeight = 0; // Calc the max tag height, in current row.
int count = ChildCount;
for (int i = 0; i < count; i++)
{
View child = GetChildAt(i);
int childWidth = child.MeasuredWidth;
int childHeight = child.MeasuredHeight;
if (child.Visibility != ViewStates.Gone)
{
rowWidth += childWidth;
if (rowWidth > widthSize)
{ // Next line.
rowWidth = childWidth; // The next row width.
height += rowMaxHeight + verticalSpacing;
rowMaxHeight = childHeight; // The next row max height.
row++;
}
else
{ // This line.
rowMaxHeight = System.Math.Max(rowMaxHeight, childHeight);
}
rowWidth += horizontalSpacing;
}
}
// Account for the last row height.
height += rowMaxHeight;
// Account for the padding too.
height += PaddingTop + PaddingBottom;
// If the tags grouped in one row, set the width to wrap the tags.
if (row == 0)
{
width = rowWidth;
width += PaddingLeft + PaddingRight;
}
else
{// If the tags grouped exceed one line, set the width to match the parent.
width = widthSize;
}
SetMeasuredDimension(widthMode == MeasureSpecMode.Exactly ? widthSize : width,
heightMode == MeasureSpecMode.Exactly ? heightSize : height);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
CoreUtility.ExecuteMethod("OnMeasure", delegate()
{
LayoutParams parameters = LayoutParameters;
MeasureSpecMode widthMode = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode heightMode = MeasureSpec.GetMode(heightMeasureSpec);
int desiredWidth = 0;
int desiredHeight = 0;
// first find the largest child
for (int i = 0; i < ChildCount; i++)
{
View child = GetChildAt(i);
if (i == 0)
{
LayoutParams childParams = child.LayoutParameters;
childParams.Height = LayoutParams.MatchParent;
child.LayoutParameters = childParams;
}
MeasureChild(child, widthMeasureSpec, heightMeasureSpec);
if (i != 0)
{
desiredWidth = Math.Max(child.MeasuredWidth, desiredWidth);
desiredHeight = Math.Max(child.MeasuredHeight, desiredHeight);
}
}
// create new measure spec using the primary child
widthMeasureSpec = MeasureSpec.MakeMeasureSpec(desiredWidth, widthMode);
heightMeasureSpec = MeasureSpec.MakeMeasureSpec(desiredHeight, heightMode);
int measuredWidth = MeasureSpec.GetSize(widthMeasureSpec);
int measuredHeight = MeasureSpec.GetSize(heightMeasureSpec);
for (int i = 0; i < ChildCount; i++)
{
View child = GetChildAt(i);
LayoutParams childParams = child.LayoutParameters;
if (childParams != null)
{
if (childParams.Height == LayoutParams.MatchParent)
{
child.SetMinimumHeight(measuredHeight);
}
if (childParams.Width == LayoutParams.MatchParent)
{
child.SetMinimumWidth(measuredWidth);
}
}
MeasureChild(child, widthMeasureSpec, heightMeasureSpec);
desiredWidth = Math.Max(child.MeasuredWidth, desiredWidth);
desiredHeight = Math.Max(child.MeasuredHeight, desiredHeight);
}
// taking accounts of padding
desiredWidth += PaddingLeft + PaddingRight;
desiredHeight += PaddingTop + PaddingBottom;
// adjust desired width
if (widthMode == MeasureSpecMode.Exactly)
{
desiredWidth = measuredWidth;
}
else
{
if (parameters.Width == LayoutParams.MatchParent)
{
desiredWidth = measuredWidth;
}
if (widthMode == MeasureSpecMode.AtMost)
{
desiredWidth = (desiredWidth > measuredWidth) ? measuredWidth : desiredWidth;
}
}
// adjust desired height
if (heightMode == MeasureSpecMode.Exactly)
{
desiredHeight = measuredHeight;
}
else
{
if (parameters.Height == LayoutParams.MatchParent)
{
desiredHeight = measuredHeight;
}
if (heightMode == MeasureSpecMode.AtMost)
{
desiredHeight = (desiredHeight > measuredHeight) ? measuredHeight : desiredHeight;
}
}
SetMeasuredDimension(desiredWidth, desiredHeight);
});
}
internal static int MakeMeasureSpec(int width, MeasureSpecMode exactly)
{
return((int)(width + exactly));
}
private String modeToString(MeasureSpecMode mode)
{
switch (mode)
{
case MeasureSpecMode.AtMost:
return "AT MOST";
case MeasureSpecMode.Exactly:
return "EXACTLY";
case MeasureSpecMode.Unspecified:
return "UNSPECIFIED";
}
return "ERROR";
}
protected override (float measuredWidth, float measuredHeight) OnMesure(float widthSpec, float heightSpec, MeasureSpecMode mode)
{
if (Children.Count > 0)
{
OnLayout();
var child = Children[0];
child.Mesure(widthSpec, heightSpec, mode);
OnLayout();
return(child.CalculatedWidth, child.CalculatedHeight);
}
return(base.OnMesure(widthSpec, heightSpec, mode));
}
/// <summary>
/// Based on internal class Xamarin.Forms.Platform.Android.MeasureSpecFactory
/// </summary>
/// <param name="size">The size.</param>
/// <param name="mode">The mode.</param>
/// <returns></returns>
private static int MakeMeasureSpec ( int size , MeasureSpecMode mode ) {
return ( int ) ( size + mode );
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
if (!hasDrawable)
{
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
return;
}
Drawable d = Drawable;
int drawableW = getDrawableWidth(d);
int drawableH = getDrawableHeight(d);
int pWidth = MeasureSpec.GetSize(widthMeasureSpec);
int pHeight = MeasureSpec.GetSize(heightMeasureSpec);
MeasureSpecMode widthMode = MeasureSpec.GetMode(widthMeasureSpec);
MeasureSpecMode heightMode = MeasureSpec.GetMode(heightMeasureSpec);
int width = 0;
int height = 0;
ViewGroup.LayoutParams p = LayoutParameters;
if (p == null)
{
p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WrapContent, ViewGroup.LayoutParams.WrapContent);
}
if (p.Width == ViewGroup.LayoutParams.MatchParent)
{
if (widthMode == MeasureSpecMode.Unspecified)
{
width = drawableW;
}
else
{
width = pWidth;
}
}
else
{
if (widthMode == MeasureSpecMode.Exactly)
{
width = pWidth;
}
else if (widthMode == MeasureSpecMode.AtMost)
{
width = drawableW > pWidth ? pWidth : drawableW;
}
else
{
width = drawableW;
}
}
if (p.Height == ViewGroup.LayoutParams.MatchParent)
{
if (heightMode == MeasureSpecMode.Unspecified)
{
height = drawableH;
}
else
{
height = pHeight;
}
}
else
{
if (heightMode == MeasureSpecMode.Exactly)
{
height = pHeight;
}
else if (heightMode == MeasureSpecMode.AtMost)
{
height = drawableH > pHeight ? pHeight : drawableH;
}
else
{
height = drawableH;
}
}
if (mAdjustViewBounds && (float)drawableW / drawableH != (float)width / height)
{
float hScale = (float)height / drawableH;
float wScale = (float)width / drawableW;
float scale = hScale < wScale ? hScale : wScale;
width = p.Width == ViewGroup.LayoutParams.MatchParent ? width : (int)(drawableW * scale);
height = p.Height == ViewGroup.LayoutParams.MatchParent ? height : (int)(drawableH * scale);
}
SetMeasuredDimension(width, height);
}
public static int MakeMeasureSpec(int size, MeasureSpecMode mode)
{
return(size + (int)mode);
}
protected override void OnLayout(bool changed, int l, int t, int r, int b)
{
mLines.Clear();
mLineHeights.Clear();
mLineMargins.Clear();
int width = Width;
int height = Height;
int linesSum = PaddingTop;
int lineWidth = 0;
int lineHeight = 0;
IList <View> lineViews = new List <View>();
float horizontalGravityFactor;
switch ((mGravity & GravityFlags.HorizontalGravityMask))
{
case GravityFlags.Left:
default:
horizontalGravityFactor = 0;
break;
case GravityFlags.CenterHorizontal:
horizontalGravityFactor = .5f;
break;
case GravityFlags.Right:
horizontalGravityFactor = 1;
break;
}
for (int i = 0; i < ChildCount; i++)
{
View child = GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
CustomLayoutParams lp = (CustomLayoutParams)child.LayoutParameters;
int childWidth = child.MeasuredWidth + lp.LeftMargin + lp.RightMargin;
int childHeight = child.MeasuredHeight + lp.BottomMargin + lp.TopMargin;
if (lineWidth + childWidth > width)
{
mLineHeights.Add(lineHeight);
mLines.Add(lineViews);
mLineMargins.Add((int)((width - lineWidth) * horizontalGravityFactor) + PaddingLeft);
linesSum += lineHeight;
lineHeight = 0;
lineWidth = 0;
lineViews = new List <View>();
}
lineWidth += childWidth;
lineHeight = Math.Max(lineHeight, childHeight);
lineViews.Add(child);
}
mLineHeights.Add(lineHeight);
mLines.Add(lineViews);
mLineMargins.Add((int)((width - lineWidth) * horizontalGravityFactor) + PaddingLeft);
linesSum += lineHeight;
int verticalGravityMargin = 0;
switch ((mGravity & GravityFlags.VerticalGravityMask))
{
case GravityFlags.Top:
default:
break;
case GravityFlags.CenterVertical:
verticalGravityMargin = (height - linesSum) / 2;
break;
case GravityFlags.Bottom:
verticalGravityMargin = height - linesSum;
break;
}
int numLines = mLines.Count;
int left;
int top = PaddingTop;
for (int i = 0; i < numLines; i++)
{
lineHeight = mLineHeights[i];
lineViews = mLines[i];
left = mLineMargins[i];
int children = lineViews.Count;
for (int j = 0; j < children; j++)
{
View child = lineViews[j];
if (child.Visibility == ViewStates.Gone)
{
continue;
}
CustomLayoutParams lp = (CustomLayoutParams)child.LayoutParameters;
// if height is match_parent we need to remeasure child to line height
if (lp.Height == LayoutParams.MatchParent)
{
MeasureSpecMode childWidthMode = MeasureSpecMode.AtMost;
int childWidthSize = lineWidth;
if (lp.Width == LayoutParams.MatchParent)
{
childWidthMode = MeasureSpecMode.Exactly;
}
else if (lp.Width >= 0)
{
childWidthMode = MeasureSpecMode.Exactly;
childWidthSize = lp.Width;
}
child.Measure(MeasureSpec.MakeMeasureSpec(childWidthSize, childWidthMode), MeasureSpec.MakeMeasureSpec(lineHeight - lp.TopMargin - lp.BottomMargin, MeasureSpecMode.Exactly));
}
int childWidth = child.MeasuredWidth;
int childHeight = child.MeasuredHeight;
int gravityMargin = 0;
if (Android.Views.Gravity.IsVertical(lp.gravity))
{
switch (lp.gravity)
{
case GravityFlags.Top:
default:
break;
case GravityFlags.CenterVertical:
case GravityFlags.Center:
gravityMargin = (lineHeight - childHeight - lp.TopMargin - lp.BottomMargin) / 2;
break;
case GravityFlags.Bottom:
gravityMargin = lineHeight - childHeight - lp.TopMargin - lp.BottomMargin;
break;
}
}
child.Layout(left + lp.LeftMargin, top + lp.TopMargin + gravityMargin + verticalGravityMargin, left + childWidth + lp.LeftMargin, top + childHeight + lp.TopMargin + gravityMargin + verticalGravityMargin);
left += childWidth + lp.LeftMargin + lp.RightMargin;
}
top += lineHeight;
}
}
