protected override void OnMeasure(
int widthMeasureSpec,
int heightMeasureSpec)
{
Size availableSize = new Size(
MeasureSpec.GetSize(widthMeasureSpec) - this.PaddingLeft - this.PaddingRight,
MeasureSpec.GetSize(heightMeasureSpec) - this.PaddingTop - this.PaddingBottom);
#if DEBUG
var widthMode = MeasureSpec.GetMode(widthMeasureSpec);
var heightMode = MeasureSpec.GetMode(heightMeasureSpec);
#endif
// Keep track of the space used by children
double usedLeft = 0;
double usedTop = 0;
double usedRight = 0;
double usedBottom = 0;
// Keep track of the starting point for measuring each dimension
// in support of overlay regions
double startLeft = 0;
double startTop = 0;
double startRight = 0;
double startBottom = 0;
double minWidth = 0;
double minHeight = 0;
var remainingSize = availableSize;
int childState = 0;
int childCount = this.ChildCount;
for (int i = 0; i < childCount; i += 1)
{
AndroidView child = this.GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
var layoutParams = (LayoutParams)child.LayoutParameters;
var dockRegion = layoutParams.DockRegion;
// Arrange all but the center elements
if (dockRegion != DockRegion.CenterOverlay)
{
LayoutAxis axis = GetLayoutAxis(dockRegion);
// Save the child width and height
int childWidth = layoutParams.Width;
int childHeight = layoutParams.Height;
// Overwrite child MatchParent size on the stacking axis
if ((axis == LayoutAxis.Horizontal) && (childWidth == LayoutParams.MatchParent))
{
childWidth = LayoutParams.WrapContent;
}
else if ((axis == LayoutAxis.Vertical) && (childHeight == LayoutParams.MatchParent))
{
childHeight = LayoutParams.WrapContent;
}
// Measure the child
this.MeasureChildWithMarginsOverride(
child,
widthMeasureSpec,
(int)(usedLeft + usedRight),
childWidth,
heightMeasureSpec,
(int)(usedTop + usedBottom),
childHeight);
Size childUsedSize = GetChildUsedSizeWithMargins(child, layoutParams);
if (dockRegion == DockRegion.Left)
{
usedLeft = Math.Max(usedLeft, startLeft + childUsedSize.Width);
startLeft += childUsedSize.Width;
minHeight = Math.Max(minHeight, usedTop + usedBottom + childUsedSize.Height);
}
else if (dockRegion == DockRegion.LeftOverlay)
{
usedLeft = Math.Max(usedLeft, startLeft + childUsedSize.Width);
minHeight = Math.Max(minHeight, usedTop + usedBottom + childUsedSize.Height);
}
else if (dockRegion == DockRegion.Top)
{
usedTop = Math.Max(usedTop, startTop + childUsedSize.Height);
startTop += childUsedSize.Height;
minWidth = Math.Max(minWidth, usedLeft + usedRight + childUsedSize.Width);
}
else if (dockRegion == DockRegion.TopOverlay)
{
usedTop = Math.Max(usedTop, startTop + childUsedSize.Height);
minWidth = Math.Max(minWidth, usedLeft + usedRight + childUsedSize.Width);
}
else if (dockRegion == DockRegion.Right)
{
usedRight = Math.Max(usedRight, startRight + childUsedSize.Width);
startRight += childUsedSize.Width;
minHeight = Math.Max(minHeight, usedTop + usedBottom + childUsedSize.Height);
}
else if (dockRegion == DockRegion.RightOverlay)
{
usedRight = Math.Max(usedRight, startRight + childUsedSize.Width);
minHeight = Math.Max(minHeight, usedTop + usedBottom + childUsedSize.Height);
}
else if (dockRegion == DockRegion.Bottom)
{
usedBottom = Math.Max(usedBottom, startBottom + childUsedSize.Height);
startBottom += childUsedSize.Height;
minWidth = Math.Max(minWidth, usedLeft + usedRight + childUsedSize.Width);
}
else if (dockRegion == DockRegion.BottomOverlay)
{
usedBottom = Math.Max(usedBottom, startBottom + childUsedSize.Height);
minWidth = Math.Max(minWidth, usedLeft + usedRight + childUsedSize.Width);
}
else
{
throw new NotSupportedException("Unsupported dock region.");
}
// Update the remaining size
remainingSize = new Size(
(float)Math.Max(0, availableSize.Width - startLeft - startRight),
(float)Math.Max(0, availableSize.Height - startTop - startBottom));
// Update the child state
childState = CombineMeasuredStates(childState, child.MeasuredState);
}
}
// Measure the center elements now that the center size has been completely calculated
Size usedCenterSize = new Size(0, 0);
for (int i = 0; i < childCount; i += 1)
{
AndroidView child = this.GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
var layoutParams = (LayoutParams)child.LayoutParameters;
var dockRegion = layoutParams.DockRegion;
// Arrange only the center elements
if (dockRegion != DockRegion.CenterOverlay)
{
continue;
}
this.MeasureChildWithMarginsOverride(
child,
widthMeasureSpec,
(int)(usedLeft + usedRight),
layoutParams.Width,
heightMeasureSpec,
(int)(usedTop + usedBottom),
layoutParams.Height);
Size childUsedSize = GetChildUsedSizeWithMargins(child, layoutParams);
usedCenterSize = new Size(
Math.Max(usedCenterSize.Width, childUsedSize.Width),
Math.Max(usedCenterSize.Height, childUsedSize.Height));
childState = CombineMeasuredStates(childState, child.MeasuredState);
}
// Calculate the total size used by children
Size usedSize = new Size(
(float)Math.Max(minWidth, usedLeft + usedRight + usedCenterSize.Width),
(float)Math.Max(minHeight, usedTop + usedBottom + usedCenterSize.Height));
// Default the final size to the size used by children
var finalSize = new Size(
usedSize.Width + this.PaddingLeft + this.PaddingRight,
usedSize.Height + this.PaddingTop + this.PaddingBottom);
int dimensionX = ResolveSizeAndState((int)finalSize.Width, widthMeasureSpec, childState);
int dimensionY = ResolveSizeAndState((int)finalSize.Height, heightMeasureSpec, childState);
this.SetMeasuredDimension(dimensionX, dimensionY);
}
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int resWidth = 0;
int resHeight = 0;
int width = MeasureSpec.GetSize(widthMeasureSpec);
int widthMode = (int)MeasureSpec.GetMode(widthMeasureSpec);
int height = MeasureSpec.GetSize(heightMeasureSpec);
int heightMode = (int)MeasureSpec.GetMode(heightMeasureSpec);
if (widthMode != (int)MeasureSpecMode.Exactly ||
heightMode != (int)MeasureSpecMode.Exactly)
{
resWidth = getSuggestedMinimumWidth();
resWidth = resWidth == 0 ? getDefaultWidth() : resWidth;
resHeight = getSuggestedMinimumHeight();
resHeight = resHeight == 0 ? getDefaultWidth() : resHeight;
}
else
{
resWidth = resHeight = Math.Min(width, height);
}
SetMeasuredDimension(resWidth, resHeight);
mRadius = Math.Max(GetMeasuredWidth(), GetMeasuredHeight());
int count = getChildCount();
// menu ite
int childSize = (int)(mRadius * RADIO_DEFAULT_CHILD_DIMENSION);
// menu item
int childMode = (int)MeasureSpecMode.Exactly;
for (int i = 0; i < count; i++)
{
View child = GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
// menu item
int makeMeasureSpec = -1;
if (child.Id == Resource.Id.circle_menu_item_center)
{
makeMeasureSpec = MeasureSpec.MakeMeasureSpec(
(int)(mRadius * RADIO_DEFAULT_CENTERITEM_DIMENSION),
MeasureSpec.GetMode(childMode));
}
else
{
makeMeasureSpec = (int)MeasureSpec.MakeMeasureSpec(childSize,
MeasureSpec.GetMode(childMode));
}
child.Measure(makeMeasureSpec, makeMeasureSpec);
}
mPadding = RADIO_PADDING_LAYOUT * mRadius;
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
int widthSize = MeasureSpec.GetSize(widthMeasureSpec);
int widthMode = (int)MeasureSpec.GetMode(widthMeasureSpec);
int heightSize = MeasureSpec.GetSize(heightMeasureSpec);
int heightMode = (int)MeasureSpec.GetMode(heightMeasureSpec);
mHorizontalSpacingForRow.Clear();
mChildNumForRow.Clear();
mHeightForRow.Clear();
int measuredHeight = 0, measuredWidth = 0, childCount = ChildCount;
int rowWidth = 0, maxChildHeightInRow = 0, childNumInRow = 0;
int rowSize = widthSize - PaddingLeft - PaddingRight;
bool allowFlow = widthMode != 0 && mFlow;
int childSpacing = mChildSpacing == SPACING_AUTO && widthMode == (int)MeasureSpecMode.Unspecified
? 0 : mChildSpacing;
float tmpSpacing = childSpacing == SPACING_AUTO ? (int)MeasureSpecMode.Unspecified : childSpacing;
for (int i = 0; i < childCount; i++)
{
View child = GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
LayoutParams childParams = child.LayoutParameters;
int horizontalMargin = 0;
int verticalMargin = 0;
if (childParams is MarginLayoutParams)
{
MeasureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, measuredHeight);
MarginLayoutParams marginParams = (MarginLayoutParams)childParams;
horizontalMargin = marginParams.LeftMargin + marginParams.RightMargin;
verticalMargin = marginParams.TopMargin + marginParams.BottomMargin;
}
else
{
MeasureChild(child, widthMeasureSpec, heightMeasureSpec);
}
int childWidth = child.MeasuredWidth + horizontalMargin;
int childHeight = child.MeasuredHeight + verticalMargin;
if (allowFlow && rowWidth + childWidth > rowSize)
{ // Need flow to next row
// Save parameters for current row
mHorizontalSpacingForRow.Add(
GetSpacingForRow(childSpacing, rowSize, rowWidth, childNumInRow));
mChildNumForRow.Add(childNumInRow);
mHeightForRow.Add(maxChildHeightInRow);
if (mHorizontalSpacingForRow.Count <= mMaxRows)
{
measuredHeight += maxChildHeightInRow;
}
measuredWidth = Math.Max(measuredWidth, rowWidth);
// Place the child view to next row
childNumInRow = 1;
rowWidth = childWidth + (int)tmpSpacing;
maxChildHeightInRow = childHeight;
}
else
{
childNumInRow++;
rowWidth += (int)(childWidth + tmpSpacing);
maxChildHeightInRow = Math.Max(maxChildHeightInRow, childHeight);
}
}
// Measure remaining child views in the last row
if (mChildSpacingForLastRow == SPACING_ALIGN)
{
// For SPACING_ALIGN, use the same spacing from the row above if there is more than one
// row.
if (mHorizontalSpacingForRow.Count >= 1)
{
mHorizontalSpacingForRow.Add(
mHorizontalSpacingForRow[mHorizontalSpacingForRow.Count - 1]);
}
else
{
mHorizontalSpacingForRow.Add(
GetSpacingForRow(childSpacing, rowSize, rowWidth, childNumInRow));
}
}
else if (mChildSpacingForLastRow != SPACING_UNDEFINED)
{
// For SPACING_AUTO and specific DP values, apply them to the spacing strategy.
mHorizontalSpacingForRow.Add(
GetSpacingForRow(mChildSpacingForLastRow, rowSize, rowWidth, childNumInRow));
}
else
{
// For SPACING_UNDEFINED, apply childSpacing to the spacing strategy for the last row.
mHorizontalSpacingForRow.Add(
GetSpacingForRow(childSpacing, rowSize, rowWidth, childNumInRow));
}
mChildNumForRow.Add(childNumInRow);
mHeightForRow.Add(maxChildHeightInRow);
if (mHorizontalSpacingForRow.Count <= mMaxRows)
{
measuredHeight += maxChildHeightInRow;
}
measuredWidth = Math.Max(measuredWidth, rowWidth);
if (childSpacing == SPACING_AUTO)
{
measuredWidth = widthSize;
}
else if (widthMode == 0)
{
measuredWidth = measuredWidth + PaddingLeft + PaddingRight;
}
else
{
measuredWidth = Math.Min(measuredWidth + PaddingLeft + PaddingRight, widthSize);
}
measuredHeight += PaddingTop + PaddingBottom;
int rowNum = Math.Min(mHorizontalSpacingForRow.Count, mMaxRows);
float rowSpacing = (mRowSpacing == SPACING_AUTO && heightMode == (int)MeasureSpecMode.Unspecified) ? 0 : mRowSpacing;
if (rowSpacing == SPACING_AUTO)
{
if (rowNum > 1)
{
mAdjustedRowSpacing = (heightSize - measuredHeight) / (rowNum - 1);
}
else
{
mAdjustedRowSpacing = 0;
}
measuredHeight = heightSize;
}
else
{
mAdjustedRowSpacing = rowSpacing;
if (rowNum > 1)
{
measuredHeight = heightMode == (int)MeasureSpecMode.Unspecified
? ((int)(measuredHeight + mAdjustedRowSpacing * (rowNum - 1)))
: (Math.Min((int)(measuredHeight + mAdjustedRowSpacing * (rowNum - 1)),
heightSize));
}
}
measuredWidth = widthMode == (int)MeasureSpecMode.Exactly ? widthSize : measuredWidth;
measuredHeight = heightMode == (int)MeasureSpecMode.Exactly ? heightSize : measuredHeight;
SetMeasuredDimension(measuredWidth, measuredHeight);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
var widthMode = MeasureSpec.GetMode(widthMeasureSpec);
var widthSize = MeasureSpec.GetSize(widthMeasureSpec);
var heightMode = MeasureSpec.GetMode(heightMeasureSpec);
var heightSize = MeasureSpec.GetSize(heightMeasureSpec);
if (widthMode != MeasureSpecMode.Exactly)
{
throw new InvalidOperationException("Width must have an exact value or match_parent");
}
if (heightMode != MeasureSpecMode.Exactly)
{
throw new InvalidOperationException("Height must have an exact value or match_parent");
}
var layoutHeight = heightSize - PaddingTop - PaddingBottom;
var panelHeight = _panelHeight;
if (ChildCount > 2)
{
Log.Error(Tag, "OnMeasure: More than two child views are not supported.");
}
else
{
panelHeight = 0;
}
_slideableView = null;
_canSlide = false;
for (var i = 0; i < ChildCount; i++)
{
var child = GetChildAt(i);
var lp = (LayoutParams)child.LayoutParameters;
var height = layoutHeight;
if (child.Visibility == ViewStates.Gone)
{
lp.DimWhenOffset = false;
continue;
}
if (i == 1)
{
lp.Slideable = true;
lp.DimWhenOffset = true;
_slideableView = child;
_canSlide = true;
}
else
{
if (!OverlayContent)
{
height -= panelHeight;
}
}
int childWidthSpec;
if (lp.Width == ViewGroup.LayoutParams.WrapContent)
{
childWidthSpec = MeasureSpec.MakeMeasureSpec(widthSize, MeasureSpecMode.AtMost);
}
else if (lp.Width == ViewGroup.LayoutParams.MatchParent)
{
childWidthSpec = MeasureSpec.MakeMeasureSpec(widthSize, MeasureSpecMode.Exactly);
}
else
{
childWidthSpec = MeasureSpec.MakeMeasureSpec(lp.Width, MeasureSpecMode.Exactly);
}
int childHeightSpec;
if (lp.Height == ViewGroup.LayoutParams.WrapContent)
{
childHeightSpec = MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.AtMost);
}
else if (lp.Height == ViewGroup.LayoutParams.MatchParent)
{
childHeightSpec = MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.Exactly);
}
else
{
childHeightSpec = MeasureSpec.MakeMeasureSpec(lp.Height, MeasureSpecMode.Exactly);
}
child.Measure(childWidthSpec, childHeightSpec);
}
SetMeasuredDimension(widthSize, heightSize);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int targetWidth = outerInstance.MeasuredWidth - outerInstance.PaddingLeft - outerInstance.PaddingRight;
widthMeasureSpec = MeasureSpec.MakeMeasureSpec(targetWidth, MeasureSpec.GetMode(widthMeasureSpec));
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
}
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));
}
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)
{
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);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
/// Assert(MeasureSpec.GetMode(widthMeasureSpec) != Android.Views.MeasureSpecMode.Unspecified);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int width = MeasureSpec.getSize(widthMeasureSpec) - getPaddingLeft() - getPaddingRight();
int width = MeasureSpec.GetSize(widthMeasureSpec) - PaddingLeft - PaddingRight;
int height = MeasureSpec.GetSize(heightMeasureSpec) - PaddingTop - PaddingBottom;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int count = getChildCount();
int count = ChildCount;
int xpos = PaddingLeft;
int ypos = PaddingTop;
int childHeightMeasureSpec;
if (MeasureSpec.GetMode(heightMeasureSpec) == Android.Views.MeasureSpecMode.AtMost)
{
childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(height, Android.Views.MeasureSpecMode.AtMost);
}
else
{
childHeightMeasureSpec = MeasureSpec.MakeMeasureSpec(0, Android.Views.MeasureSpecMode.Unspecified);
}
MHeight = 0;
int cols = 0;
MCols = 0;
for (int i = 0; i < count; i++)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final Android.view.View child = getChildAt(i);
View child = GetChildAt(i);
if (child.Visibility != Android.Views.ViewStates.Gone)
{
child.Measure(MeasureSpec.MakeMeasureSpec(width, Android.Views.MeasureSpecMode.AtMost), childHeightMeasureSpec);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int childw = child.getMeasuredWidth();
int childw = child.MeasuredWidth;
MHeight = Math.Max(MHeight, child.MeasuredHeight + PAD_V);
if (xpos + childw > width)
{
xpos = PaddingLeft;
ypos += MHeight;
MCols = Math.Max(MCols, cols);
cols = 0;
}
else
{
cols++;
}
xpos += childw + PAD_H;
}
}
MCols = Math.Max(MCols, cols);
if (MeasureSpec.GetMode(heightMeasureSpec) == Android.Views.MeasureSpecMode.Unspecified)
{
height = ypos + MHeight;
}
else if (MeasureSpec.GetMode(heightMeasureSpec) == Android.Views.MeasureSpecMode.AtMost)
{
if (ypos + MHeight < height)
{
height = ypos + MHeight;
}
}
height += 5; // Fudge to avoid clipping bottom of last row.
SetMeasuredDimension(width, height);
} // end onMeasure()
public static MeasureSpecMode GetMode(this int measureSpec)
{
return(MeasureSpec.GetMode(measureSpec));
}
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);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
var sizeWidth = MeasureSpec.GetSize(widthMeasureSpec) - PaddingRight - PaddingLeft;
var sizeHeight = MeasureSpec.GetSize(heightMeasureSpec) - PaddingRight - PaddingLeft;
var modeWidth = (int)MeasureSpec.GetMode(widthMeasureSpec);
var modeHeight = (int)MeasureSpec.GetMode(heightMeasureSpec);
int size;
int mode;
if (Orientation == Horizontal)
{
size = sizeWidth;
mode = modeWidth;
}
else
{
size = sizeHeight;
mode = modeHeight;
}
var lineThicknessWithSpacing = 0;
var lineThickness = 0;
var lineLengthWithSpacing = 0;
var prevLinePosition = 0;
var controlMaxLength = 0;
var controlMaxThickness = 0;
var count = ChildCount;
for (var i = 0; i < count; i++)
{
var child = GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
child.Measure(
MeasureSpec.MakeMeasureSpec(sizeWidth, (MeasureSpecMode)modeWidth == MeasureSpecMode.Exactly ? MeasureSpecMode.AtMost : (MeasureSpecMode)modeWidth),
MeasureSpec.MakeMeasureSpec(sizeHeight, (MeasureSpecMode)modeHeight == MeasureSpecMode.Exactly ? MeasureSpecMode.AtMost : (MeasureSpecMode)modeHeight)
);
var lp = (LayoutParams)child.LayoutParameters;
var hSpacing = GetHorizontalSpacing(lp);
var vSpacing = GetVerticalSpacing(lp);
var childWidth = child.MeasuredWidth;
var childHeight = child.MeasuredHeight;
int childLength;
int childThickness;
int spacingLength;
int spacingThickness;
if (Orientation == Horizontal)
{
childLength = childWidth;
childThickness = childHeight;
spacingLength = hSpacing;
spacingThickness = vSpacing;
}
else
{
childLength = childHeight;
childThickness = childWidth;
spacingLength = vSpacing;
spacingThickness = hSpacing;
}
var lineLength = lineLengthWithSpacing + childLength;
lineLengthWithSpacing = lineLength + spacingLength;
var newLine = lp.NewLine || ((MeasureSpecMode)mode != MeasureSpecMode.Unspecified && lineLength > size);
if (newLine)
{
prevLinePosition = prevLinePosition + lineThicknessWithSpacing;
lineThickness = childThickness;
lineLength = childLength;
lineThicknessWithSpacing = childThickness + spacingThickness;
lineLengthWithSpacing = lineLength + spacingLength;
}
lineThicknessWithSpacing = Math.Max(lineThicknessWithSpacing, childThickness + spacingThickness);
lineThickness = Math.Max(lineThickness, childThickness);
int posX;
int posY;
if (Orientation == Horizontal)
{
posX = PaddingLeft + lineLength - childLength;
posY = PaddingTop + prevLinePosition;
}
else
{
posX = PaddingLeft + prevLinePosition;
posY = PaddingTop + lineLength - childHeight;
}
lp.SetPosition(posX, posY);
controlMaxLength = Math.Max(controlMaxLength, lineLength);
controlMaxThickness = prevLinePosition + lineThickness;
}
if (Orientation == Horizontal)
{
SetMeasuredDimension(ResolveSize(controlMaxLength, widthMeasureSpec), ResolveSize(controlMaxThickness, heightMeasureSpec));
}
else
{
SetMeasuredDimension(ResolveSize(controlMaxThickness, widthMeasureSpec), ResolveSize(controlMaxLength, heightMeasureSpec));
}
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
try
{
var widthMode = (int)MeasureSpec.GetMode(widthMeasureSpec);
int widthSize = MeasureSpec.GetSize(widthMeasureSpec);
var heightMode = (int)MeasureSpec.GetMode(heightMeasureSpec);
int heightSize = MeasureSpec.GetSize(heightMeasureSpec);
if (mBitmap != null)
{
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
// Bypasses a baffling bug when used within a ScrollView, where
// heightSize is set to 0.
if (heightSize == 0)
{
heightSize = mBitmap.Height;
}
int desiredWidth;
int desiredHeight;
double viewToBitmapWidthRatio = Double.PositiveInfinity;
double viewToBitmapHeightRatio = Double.PositiveInfinity;
// Checks if either width or height needs to be fixed
if (widthSize < mBitmap.Width)
{
viewToBitmapWidthRatio = widthSize / (double)mBitmap.Width;
}
if (heightSize < mBitmap.Height)
{
viewToBitmapHeightRatio = heightSize / (double)mBitmap.Height;
}
// If either needs to be fixed, choose smallest ratio and calculate
// from there
if (viewToBitmapWidthRatio != Double.PositiveInfinity ||
viewToBitmapHeightRatio != Double.PositiveInfinity)
{
if (viewToBitmapWidthRatio <= viewToBitmapHeightRatio)
{
desiredWidth = widthSize;
desiredHeight = (int)(mBitmap.Height * viewToBitmapWidthRatio);
}
else
{
desiredHeight = heightSize;
desiredWidth = (int)(mBitmap.Width * viewToBitmapHeightRatio);
}
}
// Otherwise, the picture is within frame layout bounds. Desired
// width is
// simply picture size
else
{
desiredWidth = mBitmap.Width;
desiredHeight = mBitmap.Height;
}
int width = GetOnMeasureSpec(widthMode, widthSize, desiredWidth);
int height = GetOnMeasureSpec(heightMode, heightSize, desiredHeight);
mLayoutWidth = width;
mLayoutHeight = height;
Rect bitmapRect = ImageViewUtil.getBitmapRectCenterInside(mBitmap.Width,
mBitmap.Height,
mLayoutWidth,
mLayoutHeight);
mCropOverlayView.SetBitmapRect(bitmapRect);
// MUST CALL THIS
SetMeasuredDimension(mLayoutWidth, mLayoutHeight);
}
else
{
mCropOverlayView.SetBitmapRect(EMPTY_RECT);
SetMeasuredDimension(widthSize, heightSize);
}
}
catch (Exception ex)
{
ex.ToString();
}
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
PremeasureActions();
var widthMode = MeasureSpec.GetMode(widthMeasureSpec);
var width = MeasureSpec.GetSize(widthMeasureSpec);
var heightMode = MeasureSpec.GetMode(heightMeasureSpec);
var height = MeasureSpec.GetSize(heightMeasureSpec);
// sizes without fixed columns
double availableWidth = width;
double availableHeight = height;
// compute size for auto and star definitions
foreach (var columnInfo in _columnsInfo.Values)
{
columnInfo.Unmeasure();
}
foreach (var rowInfo in _rowsInfo.Values)
{
rowInfo.Unmeasure();
}
// measure all views that we can measure at start
MeasureFirstStageViews(width, widthMode, height, heightMode);
if (widthMode == MeasureSpecMode.Unspecified)
{
double maxLength = 0;
double maxStarLength = 0;
foreach (var columnInfo in _columnsInfo.Values)
{
if (!columnInfo.Definition.Length.IsStar || !columnInfo.IsMeasured)
{
continue;
}
if (maxStarLength == 0 ||
(_widthStarSum / columnInfo.Definition.Length.Value) * columnInfo.Length > (_widthStarSum / maxStarLength) * maxLength)
{
maxStarLength = columnInfo.Definition.Length.Value;
maxLength = columnInfo.Length;
}
}
double fullWidth = (_widthStarSum / maxStarLength) * maxLength;
foreach (var columnInfo in _columnsInfo.Values)
{
if (columnInfo.Definition.Length.IsStar)
{
columnInfo.SetLength(fullWidth * (columnInfo.Definition.Length.Value / _widthStarSum));
}
}
}
else
{
foreach (var columnInfo in _columnsInfo.Values)
{
if (columnInfo.IsMeasured)
{
availableWidth -= columnInfo.Length;
}
}
if (availableWidth > 0)
{
foreach (var columnInfo in _columnsInfo.Values)
{
if (columnInfo.Definition.Length.IsStar)
{
columnInfo.SetLength((columnInfo.Definition.Length.Value / _widthStarSum) * availableWidth);
}
}
}
}
if (heightMode == MeasureSpecMode.Unspecified)
{
double maxLength = 0;
double maxStarLength = 0;
foreach (var rowInfo in _rowsInfo.Values)
{
if (!rowInfo.Definition.Length.IsStar || !rowInfo.IsMeasured)
{
continue;
}
if (maxStarLength == 0 ||
(_widthStarSum / rowInfo.Definition.Length.Value) * rowInfo.Length > (_widthStarSum / maxStarLength) * maxLength)
{
maxStarLength = rowInfo.Definition.Length.Value;
maxLength = rowInfo.Length;
}
}
double fullHeight = (_heightStarSum / maxStarLength) * maxLength;
foreach (var rowInfo in _rowsInfo.Values)
{
if (rowInfo.Definition.Length.IsStar)
{
rowInfo.SetLength(fullHeight * (rowInfo.Definition.Length.Value / _heightStarSum));
}
}
}
else
{
foreach (var rowInfo in _rowsInfo.Values)
{
if (rowInfo.IsMeasured)
{
availableHeight -= rowInfo.Length;
}
}
if (availableHeight > 0)
{
foreach (var rowInfo in _rowsInfo.Values)
{
if (rowInfo.Definition.Length.IsStar)
{
rowInfo.SetLength((rowInfo.Definition.Length.Value / _heightStarSum) * availableHeight);
}
}
}
}
bool isAvailableSizeChanged = false;
foreach (var columnInfo in _columnsInfo.Values)
{
if (columnInfo.Definition.Length.IsAuto)
{
int maxWidth = 0;
foreach (var viewInfo in columnInfo.AttachedViews)
{
if (!viewInfo.IsMeasured)
{
double viewMeasureHeight = 0;
foreach (var row in viewInfo.AssociatedRows)
{
if (row.IsMeasured)
{
viewMeasureHeight += row.Length;
}
}
viewInfo.View.Measure(MeasureSpec.MakeMeasureSpec((int)width, MeasureSpecMode.AtMost),
MeasureSpec.MakeMeasureSpec((int)viewMeasureHeight, MeasureSpecMode.AtMost));
}
maxWidth = Math.Max(maxWidth, viewInfo.View.MeasuredWidth);
}
columnInfo.SetLength(maxWidth);
availableWidth -= maxWidth;
isAvailableSizeChanged = true;
}
}
if (isAvailableSizeChanged && heightMode != MeasureSpecMode.Unspecified)
{
foreach (var columnInfo in _columnsInfo.Values)
{
if (columnInfo.Definition.Length.IsStar)
{
if (availableWidth > 0)
{
columnInfo.SetLength((columnInfo.Definition.Length.Value / _widthStarSum) * availableWidth);
}
else
{
columnInfo.SetLength(0);
}
}
}
}
isAvailableSizeChanged = false;
foreach (var rowInfo in _rowsInfo.Values)
{
if (rowInfo.Definition.Length.IsAuto)
{
int maxHeight = 0;
foreach (var viewInfo in rowInfo.AttachedViews)
{
if (!viewInfo.IsMeasured)
{
double measureWidth = 0;
foreach (var column in viewInfo.AssociatedColumns)
{
if (column.IsMeasured)
{
measureWidth += column.Length;
}
}
viewInfo.View.Measure(MeasureSpec.MakeMeasureSpec((int)measureWidth, MeasureSpecMode.AtMost),
MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.AtMost));
}
maxHeight = Math.Max(maxHeight, viewInfo.View.MeasuredHeight);
}
rowInfo.SetLength(maxHeight);
availableHeight -= maxHeight;
isAvailableSizeChanged = true;
}
}
if (isAvailableSizeChanged && heightMode != MeasureSpecMode.Unspecified)
{
if (availableHeight > 0)
{
foreach (var rowInfo in _rowsInfo.Values)
{
if (rowInfo.Definition.Length.IsStar)
{
if (availableHeight > 0)
{
rowInfo.SetLength((rowInfo.Definition.Length.Value / _heightStarSum) * availableHeight);
}
else
{
rowInfo.SetLength(0);
}
}
}
}
}
double changedSize;
do
{
changedSize = 0;
foreach (var columnInfo in _columnsInfo.Values)
{
if (!columnInfo.Definition.Length.IsAuto)
{
continue;
}
double columnShrinkedSize = 0;
foreach (var viewInfo in columnInfo.AttachedViews)
{
double staticSizeForColumn = Math.Max(0, viewInfo.View.MeasuredWidth - viewInfo.StaticWidth);
foreach (var viewColumnInfo in viewInfo.AssociatedColumns)
{
if (staticSizeForColumn == 0)
{
break;
}
if (viewColumnInfo.Definition.Length.IsPixel || viewColumnInfo == columnInfo)
{
continue;
}
staticSizeForColumn = Math.Max(0, staticSizeForColumn - viewColumnInfo.Length);
}
columnShrinkedSize = Math.Max(columnShrinkedSize, staticSizeForColumn);
}
if (columnShrinkedSize < columnInfo.Length)
{
columnInfo.SetLength(columnShrinkedSize);
changedSize += columnInfo.Length - columnShrinkedSize;
foreach (var starColumnInfo in _columnsInfo.Values)
{
if (starColumnInfo.Definition.Length.IsStar)
{
starColumnInfo.SetLength(starColumnInfo.Length + changedSize * (starColumnInfo.Definition.Length.Value / _widthStarSum));
}
}
}
}
} while(changedSize != 0);
do
{
changedSize = 0;
foreach (var rowInfo in _rowsInfo.Values)
{
if (!rowInfo.Definition.Length.IsAuto)
{
continue;
}
double rowShrinkedSize = 0;
foreach (var viewInfo in rowInfo.AttachedViews)
{
double staticSizeForRow = Math.Max(0, viewInfo.View.MeasuredWidth - viewInfo.StaticHeight);
foreach (var viewRowInfo in viewInfo.AssociatedRows)
{
if (staticSizeForRow == 0)
{
break;
}
if (viewRowInfo.Definition.Length.IsPixel || viewRowInfo == rowInfo)
{
continue;
}
staticSizeForRow = Math.Max(0, staticSizeForRow - viewRowInfo.Length);
}
rowShrinkedSize = Math.Max(rowShrinkedSize, staticSizeForRow);
}
if (rowShrinkedSize < rowInfo.Length)
{
rowInfo.SetLength(rowShrinkedSize);
changedSize += rowInfo.Length - rowShrinkedSize;
foreach (var starRowInfo in _rowsInfo.Values)
{
if (starRowInfo.Definition.Length.IsStar)
{
starRowInfo.SetLength(starRowInfo.Length + changedSize * (starRowInfo.Definition.Length.Value / _heightStarSum));
}
}
}
}
} while(changedSize != 0);
double mWidth = 0;
double mHeight = 0;
foreach (var columnInfo in _columnsInfo.Values)
{
mWidth += columnInfo.Length;
}
foreach (var rowInfo in _rowsInfo.Values)
{
mHeight += rowInfo.Length;
}
SetMeasuredDimension((int)mWidth, (int)mHeight);
}
/// <summary>
/// Gets the size of the desired.
/// </summary>
/// <returns>The desired size.</returns>
/// <param name="widthConstraint">Width constraint.</param>
/// <param name="heightConstraint">Height constraint.</param>
public override SizeRequest GetDesiredSize(int widthConstraint, int heightConstraint)
{
if (_currentControlState.IsNullOrEmpty || Control == null)
{
return(new SizeRequest(Xamarin.Forms.Size.Zero));
}
_currentControlState.AvailWidth = MeasureSpec.GetSize(widthConstraint);
if (MeasureSpec.GetMode(widthConstraint) == Android.Views.MeasureSpecMode.Unspecified)
{
_currentControlState.AvailWidth = int.MaxValue / 2;
}
_currentControlState.AvailHeight = MeasureSpec.GetSize(heightConstraint);
if (MeasureSpec.GetMode(heightConstraint) == Android.Views.MeasureSpecMode.Unspecified)
{
_currentControlState.AvailHeight = int.MaxValue / 2;
}
if (_currentControlState.AvailWidth <= 0 || _currentControlState.AvailHeight <= 0)
{
return(new SizeRequest(Xamarin.Forms.Size.Zero));
}
if (_currentControlState == _lastControlState && _lastSizeRequest.HasValue)
{
return(_lastSizeRequest.Value);
}
ICharSequence text = _currentControlState.JavaText;
var tmpFontSize = BoundTextSize(Element.FontSize);
Control.TextSize = tmpFontSize;
Control.SetSingleLine(false);
Control.SetMaxLines(int.MaxValue / 2);
Control.SetIncludeFontPadding(false);
Control.Ellipsize = null;
int tmpHt = -1;
int tmpWd = -1;
var fontMetrics = Control.Paint.GetFontMetrics();
var fontLineHeight = fontMetrics.Descent - fontMetrics.Ascent;
var fontLeading = System.Math.Abs(fontMetrics.Bottom - fontMetrics.Descent);
if (DebugCondition)
{
System.Diagnostics.Debug.WriteLine("");
}
if (_currentControlState.Lines == 0)
{
if (_currentControlState.AvailHeight < int.MaxValue / 3)
{
tmpFontSize = F9PTextView.ZeroLinesFit(_currentControlState.JavaText, new TextPaint(Control.Paint), ModelMinFontSize, tmpFontSize, _currentControlState.AvailWidth, _currentControlState.AvailHeight);
}
}
else
{
if (_currentControlState.AutoFit == AutoFit.Lines)
{
if (_currentControlState.AvailHeight > int.MaxValue / 3)
{
tmpHt = (int)System.Math.Round(_currentControlState.Lines * fontLineHeight + (_currentControlState.Lines - 1) * fontLeading);
}
else
{
var fontPointSize = tmpFontSize;
var lineHeightRatio = fontLineHeight / fontPointSize;
var leadingRatio = fontLeading / fontPointSize;
tmpFontSize = ((_currentControlState.AvailHeight / (_currentControlState.Lines + leadingRatio * (_currentControlState.Lines - 1))) / lineHeightRatio - 0.1f);
}
}
else if (_currentControlState.AutoFit == AutoFit.Width)
{
tmpFontSize = F9PTextView.WidthFit(_currentControlState.JavaText, new TextPaint(Control.Paint), _currentControlState.Lines, ModelMinFontSize, tmpFontSize, _currentControlState.AvailWidth, _currentControlState.AvailHeight);
}
}
/*
* if (_currentControlState.Lines == 0) // && _currentControlState.AutoFit != AutoFit.None)
* tmpFontSize = F9PTextView.ZeroLinesFit(_currentControlState.JavaText, new TextPaint(Control.Paint), ModelMinFontSize, tmpFontSize, _currentControlState.AvailWidth, _currentControlState.AvailHeight);
* else if (_currentControlState.AutoFit == AutoFit.Lines)
* {
*
* if (_currentControlState.AvailHeight > int.MaxValue / 3)
* tmpHt = (int)System.Math.Round(_currentControlState.Lines * fontLineHeight + (_currentControlState.Lines - 1) * fontLeading);
* else
* {
* var fontPointSize = tmpFontSize;
* var lineHeightRatio = fontLineHeight / fontPointSize;
* var leadingRatio = fontLeading / fontPointSize;
* tmpFontSize = ((_currentControlState.AvailHeight / (_currentControlState.Lines + leadingRatio * (_currentControlState.Lines - 1))) / lineHeightRatio - 0.1f);
* }
* }
* else if (_currentControlState.AutoFit == AutoFit.Width)
* tmpFontSize = F9PTextView.WidthFit(_currentControlState.JavaText, new TextPaint(Control.Paint), _currentControlState.Lines, ModelMinFontSize, tmpFontSize, _currentControlState.AvailWidth, _currentControlState.AvailHeight);
*/
tmpFontSize = BoundTextSize(tmpFontSize);
// this is the optimal font size. Let it be known!
if (tmpFontSize != Element.FittedFontSize)
{
//Device.StartTimer(TimeSpan.FromMilliseconds(50), () =>
//{
if (Element != null && Control != null) // multipicker test was getting here with Element and Control both null
{
if (tmpFontSize == Element.FontSize || (Element.FontSize == -1 && tmpFontSize == F9PTextView.DefaultTextSize))
{
Element.FittedFontSize = -1;
}
else
{
Element.FittedFontSize = tmpFontSize;
}
}
// return false;
//});
}
var syncFontSize = (float)((ILabel)Element).SynchronizedFontSize;
if (syncFontSize >= 0 && tmpFontSize != syncFontSize)
{
tmpFontSize = syncFontSize;
}
Control.TextSize = tmpFontSize;
var layout = new StaticLayout(_currentControlState.JavaText, new TextPaint(Control.Paint), _currentControlState.AvailWidth, Android.Text.Layout.Alignment.AlignNormal, 1.0f, 0.0f, true);
int lines = _currentControlState.Lines;
if (lines == 0 && _currentControlState.AutoFit == AutoFit.None)
{
for (int i = 0; i < layout.LineCount; i++)
{
if (layout.GetLineBottom(i) <= _currentControlState.AvailHeight - layout.TopPadding - layout.BottomPadding)
{
lines++;
}
else
{
break;
}
}
}
if (layout.Height > _currentControlState.AvailHeight || (lines > 0 && layout.LineCount > lines))
{
if (_currentControlState.Lines == 1)
{
Control.SetSingleLine(true);
Control.SetMaxLines(1);
Control.Ellipsize = _currentControlState.LineBreakMode.ToEllipsize();
}
else
{
layout = F9PTextView.Truncate(_currentControlState.Text, Element.F9PFormattedString, new TextPaint(Control.Paint), _currentControlState.AvailWidth, _currentControlState.AvailHeight, Element.AutoFit, Element.LineBreakMode, ref lines, ref text);
}
}
lines = lines > 0 ? System.Math.Min(lines, layout.LineCount) : layout.LineCount;
for (int i = 0; i < lines; i++)
{
tmpHt = layout.GetLineBottom(i);
var width = layout.GetLineWidth(i);
//System.Diagnostics.Debug.WriteLine("\t\tright=["+right+"]");
if (width > tmpWd)
{
tmpWd = (int)System.Math.Ceiling(width);
}
}
if (_currentControlState.AutoFit == AutoFit.None && _currentControlState.Lines > 0)
{
Control.SetMaxLines(_currentControlState.Lines);
}
//System.Diagnostics.Debug.WriteLine("\tLabelRenderer.GetDesiredSize\ttmp.size=[" + tmpWd + ", " + tmpHt + "]");
if (Element.IsDynamicallySized && _currentControlState.Lines > 0 && _currentControlState.AutoFit == AutoFit.Lines)
{
fontMetrics = Control.Paint.GetFontMetrics();
fontLineHeight = fontMetrics.Descent - fontMetrics.Ascent;
fontLeading = System.Math.Abs(fontMetrics.Bottom - fontMetrics.Descent);
tmpHt = (int)(fontLineHeight * _currentControlState.Lines + fontLeading * (_currentControlState.Lines - 1));
}
Control.Gravity = Element.HorizontalTextAlignment.ToHorizontalGravityFlags() | Element.VerticalTextAlignment.ToVerticalGravityFlags();
if (Element.Text != null)
{
Control.Text = text.ToString();
}
else
{
Control.TextFormatted = text;
}
_lastSizeRequest = new SizeRequest(new Xamarin.Forms.Size(tmpWd, tmpHt), new Xamarin.Forms.Size(10, tmpHt));
if (showDebugMsg)
{
Control.SetWidth((int)_lastSizeRequest.Value.Request.Width);
Control.SetHeight((int)_lastSizeRequest.Value.Request.Height);
System.Diagnostics.Debug.WriteLine("\t[" + elementText + "] LabelRenderer.GetDesiredSize(" + (_currentControlState.AvailWidth > int.MaxValue / 3 ? "infinity" : _currentControlState.AvailWidth.ToString()) + "," + (_currentControlState.AvailHeight > int.MaxValue / 3 ? "infinity" : _currentControlState.AvailHeight.ToString()) + ") exit (" + _lastSizeRequest.Value + ")");
System.Diagnostics.Debug.WriteLine("\t\tControl.Visibility=[" + Control.Visibility + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.TextFormatted=[" + Control.TextFormatted + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.TextSize=[" + Control.TextSize + "]");
//System.Diagnostics.Debug.WriteLine("\t\tControl.ClipBounds=["+Control.ClipBounds.Width()+","+Control.ClipBounds.Height()+"]");
System.Diagnostics.Debug.WriteLine("\t\tControl.Width[" + Control.Width + "] .Height=[" + Control.Height + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.GetX[" + Control.GetX() + "] .GetY[" + Control.GetY() + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.Alpha[" + Control.Alpha + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.Background[" + Control.Background + "]");
//System.Diagnostics.Debug.WriteLine("\t\tControl.Elevation["+Control.Elevation+"]");
System.Diagnostics.Debug.WriteLine("\t\tControl.Enabled[" + Control.Enabled + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.Error[" + Control.Error + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.IsOpaque[" + Control.IsOpaque + "]");
System.Diagnostics.Debug.WriteLine("\t\tControl.IsShown[" + Control.IsShown + "]");
//Control.BringToFront();
System.Diagnostics.Debug.WriteLine("\t\t");
}
if (Element.LineBreakMode == LineBreakMode.NoWrap)
{
Control.SetSingleLine(true);
}
_lastControlState = new ControlState(_currentControlState);
return(_lastSizeRequest.Value);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
// need to call base.OnMeasure(...) otherwise Get some funny behaviour
base.OnMeasure(widthMeasureSpec, heightMeasureSpec);
int width = MeasureSpec.GetSize(widthMeasureSpec);
int height = MeasureSpec.GetSize(heightMeasureSpec);
// increment the x position as we progress through a line
int xpos = GetPaddingLeft();
// increment the y position as we progress through the lines
int ypos = GetPaddingTop();
// the height of the current line
int line_height = 0;
// go through children
// to work out the height required for this view
// call to measure size of children not needed I think?!
// Getting child's measured height/width seems to work okay without it
//measureChildren(widthMeasureSpec, heightMeasureSpec);
View child;
MarginLayoutParams childMarginLayoutParams;
int childWidth, childHeight, childMarginLeft, childMarginRight, childMarginTop, childMarginBottom;
for (int i = 0; i < GetChildCount(); i++)
{
child = GetChildAt(i);
if (child.GetVisibility() != GONE)
{
childWidth = child.GetMeasuredWidth();
childHeight = child.GetMeasuredHeight();
if (child.GetLayoutParams() != null &&
child.GetLayoutParams() is MarginLayoutParams)
{
childMarginLayoutParams = (MarginLayoutParams)child.GetLayoutParams();
childMarginLeft = childMarginLayoutParams.LeftMargin;
childMarginRight = childMarginLayoutParams.RightMargin;
childMarginTop = childMarginLayoutParams.TopMargin;
childMarginBottom = childMarginLayoutParams.BottomMargin;
}
else
{
childMarginLeft = 0;
childMarginRight = 0;
childMarginTop = 0;
childMarginBottom = 0;
}
if (xpos + childMarginLeft + childWidth + childMarginRight + GetPaddingRight() > width)
{
// this child will need to go on a new line
xpos = GetPaddingLeft();
ypos += line_height;
line_height = childMarginTop + childHeight + childMarginBottom;
}
else
{
// enough space for this child on the current line
line_height = Math.Max(
line_height,
childMarginTop + childHeight + childMarginBottom);
}
xpos += childMarginLeft + childWidth + childMarginRight;
}
}
ypos += line_height + GetPaddingBottom();
if (MeasureSpec.GetMode(heightMeasureSpec) == MeasureSpec.UNSPECIFIED)
{
// set height as measured since there's no height restrictions
height = ypos;
}
else if (MeasureSpec.GetMode(heightMeasureSpec) == MeasureSpec.AT_MOST &&
ypos < height)
{
// set height as measured since it's less than the maximum allowed
height = ypos;
}
SetMeasuredDimension(width, height);
}
protected override void OnMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
int resWidth = 0;
int resHeight = 0;
int width = MeasureSpec.GetSize(widthMeasureSpec);
int widthMode = (int)MeasureSpec.GetMode(widthMeasureSpec);
int height = MeasureSpec.GetSize(heightMeasureSpec);
int heightMode = (int)MeasureSpec.GetMode(heightMeasureSpec);
if (widthMode != (int)MeasureSpecMode.Exactly ||
heightMode != (int)MeasureSpecMode.Exactly)
{
resWidth = this.SuggestedMinimumWidth;
resWidth = resWidth == 0 ? getDefaultWidth() : resWidth;
resHeight = this.SuggestedMinimumHeight;
resHeight = resHeight == 0 ? getDefaultWidth() : resHeight;
}
else
{
resWidth = resHeight = Math.Min(width, height);
}
SetMeasuredDimension(resWidth, resHeight);
var metrics = Resources.DisplayMetrics;
var widthInDp = ConvertPixelsToDp(metrics.WidthPixels);
var heightInDp = ConvertPixelsToDp(metrics.HeightPixels);
mRadius = Math.Max(this.MeasuredHeight, this.MeasuredWidth);//Math.Max(widthInDp, heightInDp);
int count = ChildCount;
// menu item
int childSize = (int)(mRadius * RADIO_DEFAULT_CHILD_DIMENSION);
// menu item
int childMode = (int)MeasureSpecMode.Exactly;
for (int i = 0; i < count; i++)
{
View child = GetChildAt(i);
if (child.Visibility == ViewStates.Gone)
{
continue;
}
// menu item
int makeMeasureSpec = -1;
if (child.Id == Resource.Id.circle_menu_item_center)
{
makeMeasureSpec = MeasureSpec.MakeMeasureSpec(
(int)(mRadius * RADIO_DEFAULT_CENTERITEM_DIMENSION),
MeasureSpec.GetMode(childMode));
}
else
{
makeMeasureSpec = (int)MeasureSpec.MakeMeasureSpec(childSize,
MeasureSpec.GetMode(childMode));
}
child.Measure(makeMeasureSpec, makeMeasureSpec);
}
mPadding = RADIO_PADDING_LAYOUT * mRadius;
base.OnMeasure(
MeasureSpec.MakeMeasureSpec(width, MeasureSpecMode.Exactly),
MeasureSpec.MakeMeasureSpec(height, MeasureSpecMode.Exactly)
);
}
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);
}
