/// <summary>
/// Ask one of the children of this view to measure itself, taking into
/// account both the MeasureSpec requirements for this view and its padding
/// and margins.
/// </summary>
/// <remarks>
/// Ask one of the children of this view to measure itself, taking into
/// account both the MeasureSpec requirements for this view and its padding
/// and margins. The child must have MarginLayoutParams The heavy lifting is
/// done in getChildMeasureSpec.
/// </remarks>
/// <param name="child">The child to measure</param>
/// <param name="parentWidthMeasureSpec">The width requirements for this view</param>
/// <param name="widthUsed">
/// Extra space that has been used up by the parent
/// horizontally (possibly by other children of the parent)
/// </param>
/// <param name="parentHeightMeasureSpec">The height requirements for this view</param>
/// <param name="heightUsed">
/// Extra space that has been used up by the parent
/// vertically (possibly by other children of the parent)
/// </param>
protected internal virtual void measureChildWithMargins(android.view.View child,
int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed
)
{
android.view.ViewGroup.MarginLayoutParams lp = (android.view.ViewGroup.MarginLayoutParams
)child.getLayoutParams();
int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft
+ mPaddingRight + lp.leftMargin + lp.rightMargin + widthUsed, lp.width);
int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
/// <summary>Adds a child view.</summary>
/// <remarks>
/// Adds a child view. If no layout parameters are already set on the child, the
/// default parameters for this ViewGroup are set on the child.
/// </remarks>
/// <param name="child">the child view to add</param>
/// <param name="index">the position at which to add the child</param>
/// <seealso cref="generateDefaultLayoutParams()">generateDefaultLayoutParams()</seealso>
public virtual void addView(android.view.View child, int index)
{
android.view.ViewGroup.LayoutParams @params = child.getLayoutParams();
if (@params == null)
{
@params = generateDefaultLayoutParams();
if (@params == null)
{
throw new System.ArgumentException("generateDefaultLayoutParams() cannot return null"
);
}
}
addView(child, index, @params);
}
/// <summary>
/// Ask one of the children of this view to measure itself, taking into
/// account both the MeasureSpec requirements for this view and its padding.
/// </summary>
/// <remarks>
/// Ask one of the children of this view to measure itself, taking into
/// account both the MeasureSpec requirements for this view and its padding.
/// The heavy lifting is done in getChildMeasureSpec.
/// </remarks>
/// <param name="child">The child to measure</param>
/// <param name="parentWidthMeasureSpec">The width requirements for this view</param>
/// <param name="parentHeightMeasureSpec">The height requirements for this view</param>
protected internal virtual void measureChild(android.view.View child, int parentWidthMeasureSpec
, int parentHeightMeasureSpec)
{
android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec, mPaddingLeft
+ mPaddingRight, lp.width);
int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ mPaddingBottom, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
/// <summary>
/// Helper for makeAndAddView to set the position of a view
/// and fill out its layout paramters.
/// </summary>
/// <remarks>
/// Helper for makeAndAddView to set the position of a view
/// and fill out its layout paramters.
/// </remarks>
/// <param name="child">The view to position</param>
private void setUpChild(android.view.View child)
{
// Respect layout params that are already in the view. Otherwise
// make some up...
android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
if (lp == null)
{
lp = generateDefaultLayoutParams();
}
addViewInLayout(child, 0, lp);
child.setSelected(hasFocus());
// Get measure specs
int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(mHeightMeasureSpec
, mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(mWidthMeasureSpec
, mSpinnerPadding.left + mSpinnerPadding.right, lp.width);
// Measure child
child.measure(childWidthSpec, childHeightSpec);
int childLeft;
int childRight;
// Position vertically based on gravity setting
int childTop = mSpinnerPadding.top + ((getMeasuredHeight() - mSpinnerPadding.bottom
- mSpinnerPadding.top - child.getMeasuredHeight()) / 2);
int childBottom = childTop + child.getMeasuredHeight();
int width = child.getMeasuredWidth();
childLeft = 0;
childRight = childLeft + width;
child.layout(childLeft, childTop, childRight, childBottom);
}
public override void addView(android.view.View child)
{
if (child.getLayoutParams() == null)
{
android.widget.LinearLayout.LayoutParams lp = new android.widget.LinearLayout.LayoutParams
(0, android.view.ViewGroup.LayoutParams.MATCH_PARENT, 1.0f);
lp.setMargins(0, 0, 0, 0);
child.setLayoutParams(lp);
}
// Ensure you can navigate to the tab with the keyboard, and you can touch it
child.setFocusable(true);
child.setClickable(true);
base.addView(child);
// TODO: detect this via geometry with a tabwidget listener rather
// than potentially interfere with the view's listener
child.setOnClickListener(new android.widget.TabWidget.TabClickListener(this, getTabCount
() - 1));
child.setOnFocusChangeListener(this);
}
/// <summary>
/// Returns the amount of milliseconds by which the specified view's
/// animation must be delayed or offset.
/// </summary>
/// <remarks>
/// Returns the amount of milliseconds by which the specified view's
/// animation must be delayed or offset. Subclasses should override this
/// method to return a suitable value.
/// This implementation returns <code>child animation delay</code>
/// milliseconds where:
/// <pre>
/// child animation delay = child index * delay
/// </pre>
/// The index is retrieved from the
/// <see cref="AnimationParameters">AnimationParameters</see>
/// found in the view's
/// <see cref="android.view.ViewGroup.LayoutParams">android.view.ViewGroup.LayoutParams
/// </see>
/// .
/// </remarks>
/// <param name="view">the view for which to obtain the animation's delay</param>
/// <returns>a delay in milliseconds</returns>
/// <seealso cref="getAnimationForView(android.view.View)">getAnimationForView(android.view.View)
/// </seealso>
/// <seealso cref="getDelay()">getDelay()</seealso>
/// <seealso cref="getTransformedIndex(AnimationParameters)">getTransformedIndex(AnimationParameters)
/// </seealso>
/// <seealso cref="android.view.ViewGroup.LayoutParams">android.view.ViewGroup.LayoutParams
/// </seealso>
protected internal virtual long getDelayForView(android.view.View view)
{
android.view.ViewGroup.LayoutParams lp = view.getLayoutParams();
android.view.animation.LayoutAnimationController.AnimationParameters @params = lp
.layoutAnimationParameters;
if (@params == null)
{
return 0;
}
float delay = mDelay * mAnimation.getDuration();
long viewDelay = (long)(getTransformedIndex(@params) * delay);
float totalDelay = delay * @params.count;
if (mInterpolator == null)
{
mInterpolator = new android.view.animation.LinearInterpolator();
}
float normalizedDelay = viewDelay / totalDelay;
normalizedDelay = mInterpolator.getInterpolation(normalizedDelay);
return (long)(normalizedDelay * totalDelay);
}
/// <summary>
/// Helper for makeAndAddView to set the position of a view and fill out its
/// layout parameters.
/// </summary>
/// <remarks>
/// Helper for makeAndAddView to set the position of a view and fill out its
/// layout parameters.
/// </remarks>
/// <param name="child">The view to position</param>
/// <param name="offset">Offset from the selected position</param>
/// <param name="x">
/// X-coordinate indicating where this view should be placed. This
/// will either be the left or right edge of the view, depending on
/// the fromLeft parameter
/// </param>
/// <param name="fromLeft">
/// Are we positioning views based on the left edge? (i.e.,
/// building from left to right)?
/// </param>
private void setUpChild(android.view.View child, int offset, int x, bool fromLeft
)
{
// Respect layout params that are already in the view. Otherwise
// make some up...
android.widget.Gallery.LayoutParams lp = (android.widget.Gallery.LayoutParams)child
.getLayoutParams();
if (lp == null)
{
lp = (android.widget.Gallery.LayoutParams)generateDefaultLayoutParams();
}
addViewInLayout(child, fromLeft != mIsRtl ? -1 : 0, lp);
child.setSelected(offset == 0);
// Get measure specs
int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(mHeightMeasureSpec
, mSpinnerPadding.top + mSpinnerPadding.bottom, lp.height);
int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(mWidthMeasureSpec
, mSpinnerPadding.left + mSpinnerPadding.right, lp.width);
// Measure child
child.measure(childWidthSpec, childHeightSpec);
int childLeft;
int childRight;
// Position vertically based on gravity setting
int childTop = calculateTop(child, true);
int childBottom = childTop + child.getMeasuredHeight();
int width = child.getMeasuredWidth();
if (fromLeft)
{
childLeft = x;
childRight = childLeft + width;
}
else
{
childLeft = x - width;
childRight = x;
}
child.layout(childLeft, childTop, childRight, childBottom);
}
internal override int getNextLocationOffset(android.view.View child)
{
return ((android.widget.TableRow.LayoutParams)child.getLayoutParams()).mOffset[android.widget.TableRow
.LayoutParams.LOCATION_NEXT];
}
protected internal override void measureChild(android.view.View child, int parentWidthMeasureSpec
, int parentHeightMeasureSpec)
{
android.view.ViewGroup.LayoutParams lp = child.getLayoutParams();
int childWidthMeasureSpec;
int childHeightMeasureSpec;
childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ mPaddingBottom, lp.height);
childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(0, android.view.View
.MeasureSpec.UNSPECIFIED);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
internal override void measureChildBeforeLayout(android.view.View child, int childIndex
, int widthMeasureSpec, int totalWidth, int heightMeasureSpec, int totalHeight)
{
if (mConstrainedColumnWidths != null)
{
android.widget.TableRow.LayoutParams lp = (android.widget.TableRow.LayoutParams)child
.getLayoutParams();
int measureMode = android.view.View.MeasureSpec.EXACTLY;
int columnWidth = 0;
int span = lp.span;
int[] constrainedColumnWidths = mConstrainedColumnWidths;
{
for (int i = 0; i < span; i++)
{
columnWidth += constrainedColumnWidths[childIndex + i];
}
}
int gravity = lp.gravity;
bool isHorizontalGravity = android.view.Gravity.isHorizontal(gravity);
if (isHorizontalGravity)
{
measureMode = android.view.View.MeasureSpec.AT_MOST;
}
// no need to care about padding here,
// ViewGroup.getChildMeasureSpec() would get rid of it anyway
// because of the EXACTLY measure spec we use
int childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(System.Math.Max
(0, columnWidth - lp.leftMargin - lp.rightMargin), measureMode);
int childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, mPaddingTop +
mPaddingBottom + lp.topMargin + lp.bottomMargin + totalHeight, lp.height);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
if (isHorizontalGravity)
{
int childWidth = child.getMeasuredWidth();
lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION_NEXT] = columnWidth - childWidth;
int layoutDirection = getResolvedLayoutDirection();
int absoluteGravity = android.view.Gravity.getAbsoluteGravity(gravity, layoutDirection
);
switch (absoluteGravity & android.view.Gravity.HORIZONTAL_GRAVITY_MASK)
{
case android.view.Gravity.LEFT:
{
// don't offset on X axis
break;
}
case android.view.Gravity.RIGHT:
{
lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
.LayoutParams.LOCATION_NEXT];
break;
}
case android.view.Gravity.CENTER_HORIZONTAL:
{
lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
.LayoutParams.LOCATION_NEXT] / 2;
break;
}
}
}
else
{
lp.mOffset[android.widget.TableRow.LayoutParams.LOCATION] = lp.mOffset[android.widget.TableRow
.LayoutParams.LOCATION_NEXT] = 0;
}
}
else
{
// fail silently when column widths are not available
base.measureChildBeforeLayout(child, childIndex, widthMeasureSpec, totalWidth, heightMeasureSpec
, totalHeight);
}
}
internal override int getChildrenSkipCount(android.view.View child, int index)
{
android.widget.TableRow.LayoutParams layoutParams = (android.widget.TableRow.LayoutParams
)child.getLayoutParams();
// when the span is 1 (default), we need to skip 0 child
return layoutParams.span - 1;
}
internal override void transformViewForTransition(int fromIndex, int toIndex, android.view.View
view, bool animate_1)
{
if (!animate_1)
{
((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
view.setRotationX(0f);
android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
)view.getLayoutParams();
lp.setVerticalOffset(0);
lp.setHorizontalOffset(0);
}
if (fromIndex == -1 && toIndex == getNumActiveViews() - 1)
{
transformViewAtIndex(toIndex, view, false);
view.setVisibility(VISIBLE);
view.setAlpha(1.0f);
}
else
{
if (fromIndex == 0 && toIndex == 1)
{
((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
view.setVisibility(VISIBLE);
int duration = Sharpen.Util.Round(mStackSlider.getDurationForNeutralPosition(mYVelocity
));
android.widget.StackView.StackSlider animationSlider = new android.widget.StackView
.StackSlider(this, mStackSlider);
animationSlider.setView(view);
if (animate_1)
{
android.animation.PropertyValuesHolder slideInY = android.animation.PropertyValuesHolder
.ofFloat("YProgress", 0.0f);
android.animation.PropertyValuesHolder slideInX = android.animation.PropertyValuesHolder
.ofFloat("XProgress", 0.0f);
android.animation.ObjectAnimator slideIn = android.animation.ObjectAnimator.ofPropertyValuesHolder
(animationSlider, slideInX, slideInY);
slideIn.setDuration(duration);
slideIn.setInterpolator(new android.view.animation.LinearInterpolator());
((android.widget.StackView.StackFrame)view).setSliderAnimator(slideIn);
slideIn.start();
}
else
{
animationSlider.setYProgress(0f);
animationSlider.setXProgress(0f);
}
}
else
{
if (fromIndex == 1 && toIndex == 0)
{
((android.widget.StackView.StackFrame)view).cancelSliderAnimator();
int duration = Sharpen.Util.Round(mStackSlider.getDurationForOffscreenPosition(mYVelocity
));
android.widget.StackView.StackSlider animationSlider = new android.widget.StackView
.StackSlider(this, mStackSlider);
animationSlider.setView(view);
if (animate_1)
{
android.animation.PropertyValuesHolder slideOutY = android.animation.PropertyValuesHolder
.ofFloat("YProgress", 1.0f);
android.animation.PropertyValuesHolder slideOutX = android.animation.PropertyValuesHolder
.ofFloat("XProgress", 0.0f);
android.animation.ObjectAnimator slideOut = android.animation.ObjectAnimator.ofPropertyValuesHolder
(animationSlider, slideOutX, slideOutY);
slideOut.setDuration(duration);
slideOut.setInterpolator(new android.view.animation.LinearInterpolator());
((android.widget.StackView.StackFrame)view).setSliderAnimator(slideOut);
slideOut.start();
}
else
{
animationSlider.setYProgress(1.0f);
animationSlider.setXProgress(0f);
}
}
else
{
if (toIndex == 0)
{
view.setAlpha(0.0f);
view.setVisibility(INVISIBLE);
}
else
{
if ((fromIndex == 0 || fromIndex == 1) && toIndex > 1)
{
view.setVisibility(VISIBLE);
view.setAlpha(1.0f);
view.setRotationX(0f);
android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
)view.getLayoutParams();
lp.setVerticalOffset(0);
lp.setHorizontalOffset(0);
}
else
{
if (fromIndex == -1)
{
view.setAlpha(1.0f);
view.setVisibility(VISIBLE);
}
else
{
if (toIndex == -1)
{
if (animate_1)
{
postDelayed(new _Runnable_294(view), STACK_RELAYOUT_DURATION);
}
else
{
view.setAlpha(0f);
}
}
}
}
}
}
}
}
// Implement the faked perspective
if (toIndex != -1)
{
transformViewAtIndex(toIndex, view, animate_1);
}
}
internal override android.view.ViewGroup.LayoutParams createOrReuseLayoutParams(android.view.View
v)
{
android.view.ViewGroup.LayoutParams currentLp = v.getLayoutParams();
if (currentLp is android.widget.StackView.LayoutParams)
{
android.widget.StackView.LayoutParams lp = (android.widget.StackView.LayoutParams
)currentLp;
lp.setHorizontalOffset(0);
lp.setVerticalOffset(0);
lp.width = 0;
lp.width = 0;
return lp;
}
return new android.widget.StackView.LayoutParams(this, v);
}
/// <summary>Measure a child view to fit within cell-based formatting.</summary>
/// <remarks>
/// Measure a child view to fit within cell-based formatting. The child's width
/// will be measured to a whole multiple of cellSize.
/// <p>Sets the expandable and cellsUsed fields of LayoutParams.
/// </remarks>
/// <param name="child">Child to measure</param>
/// <param name="cellSize">Size of one cell</param>
/// <param name="cellsRemaining">Number of cells remaining that this view can expand to fill
/// </param>
/// <param name="parentHeightMeasureSpec">MeasureSpec used by the parent view</param>
/// <param name="parentHeightPadding">Padding present in the parent view</param>
/// <returns>Number of cells this child was measured to occupy</returns>
internal static int measureChildForCells(android.view.View child, int cellSize, int
cellsRemaining, int parentHeightMeasureSpec, int parentHeightPadding)
{
[email protected] lp = ([email protected]
.LayoutParams)child.getLayoutParams();
int childHeightSize = android.view.View.MeasureSpec.getSize(parentHeightMeasureSpec
) - parentHeightPadding;
int childHeightMode = android.view.View.MeasureSpec.getMode(parentHeightMeasureSpec
);
int childHeightSpec = android.view.View.MeasureSpec.makeMeasureSpec(childHeightSize
, childHeightMode);
int cellsUsed = 0;
if (cellsRemaining > 0)
{
int childWidthSpec = android.view.View.MeasureSpec.makeMeasureSpec(cellSize * cellsRemaining
, android.view.View.MeasureSpec.AT_MOST);
child.measure(childWidthSpec, childHeightSpec);
int measuredWidth = child.getMeasuredWidth();
cellsUsed = measuredWidth / cellSize;
if (measuredWidth % cellSize != 0)
{
cellsUsed++;
}
}
[email protected] itemView = child is [email protected]
? ([email protected])child : null;
bool expandable = !lp.isOverflowButton && itemView != null && itemView.hasText();
lp.expandable = expandable;
lp.cellsUsed = cellsUsed;
int targetWidth = cellsUsed * cellSize;
child.measure(android.view.View.MeasureSpec.makeMeasureSpec(targetWidth, android.view.View
.MeasureSpec.EXACTLY), childHeightSpec);
return cellsUsed;
}
protected internal override long getDelayForView(android.view.View view)
{
android.view.ViewGroup.LayoutParams lp = view.getLayoutParams();
android.view.animation.GridLayoutAnimationController.AnimationParameters @params =
(android.view.animation.GridLayoutAnimationController.AnimationParameters)lp.layoutAnimationParameters;
if (@params == null)
{
return 0;
}
int column = getTransformedColumnIndex(@params);
int row = getTransformedRowIndex(@params);
int rowsCount = @params.rowsCount;
int columnsCount = @params.columnsCount;
long duration = mAnimation.getDuration();
float columnDelay = mColumnDelay * duration;
float rowDelay = mRowDelay * duration;
float totalDelay;
long viewDelay;
if (mInterpolator == null)
{
mInterpolator = new android.view.animation.LinearInterpolator();
}
switch (mDirectionPriority)
{
case PRIORITY_COLUMN:
{
viewDelay = (long)(row * rowDelay + column * rowsCount * rowDelay);
totalDelay = rowsCount * rowDelay + columnsCount * rowsCount * rowDelay;
break;
}
case PRIORITY_ROW:
{
viewDelay = (long)(column * columnDelay + row * columnsCount * columnDelay);
totalDelay = columnsCount * columnDelay + rowsCount * columnsCount * columnDelay;
break;
}
case PRIORITY_NONE:
default:
{
viewDelay = (long)(column * columnDelay + row * rowDelay);
totalDelay = columnsCount * columnDelay + rowsCount * rowDelay;
break;
}
}
float normalizedDelay = viewDelay / totalDelay;
normalizedDelay = mInterpolator.getInterpolation(normalizedDelay);
return (long)(normalizedDelay * totalDelay);
}
protected internal override void measureChildWithMargins(android.view.View child,
int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed
)
{
android.view.ViewGroup.MarginLayoutParams lp = (android.view.ViewGroup.MarginLayoutParams
)child.getLayoutParams();
int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec, mPaddingTop
+ mPaddingBottom + lp.topMargin + lp.bottomMargin + heightUsed, lp.height);
int childWidthMeasureSpec = android.view.View.MeasureSpec.makeMeasureSpec(lp.leftMargin
+ lp.rightMargin, android.view.View.MeasureSpec.UNSPECIFIED);
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
}
public virtual void setTabContainer([email protected] tabView) { if (mTabContainer != null) { removeView(mTabContainer); } mTabContainer = tabView; if (tabView != null) { addView(tabView); android.view.ViewGroup.LayoutParams lp = tabView.getLayoutParams(); lp.width = android.view.ViewGroup.LayoutParams.MATCH_PARENT; lp.height = android.view.ViewGroup.LayoutParams.WRAP_CONTENT; tabView.setAllowCollapse(false); } }
/// <summary>
/// Add a view as a child and make sure it is measured (if necessary) and
/// positioned properly.
/// </summary>
/// <remarks>
/// Add a view as a child and make sure it is measured (if necessary) and
/// positioned properly.
/// </remarks>
/// <param name="child">The view to add</param>
/// <param name="position">The position of the view</param>
/// <param name="y">The y position relative to which this view will be positioned</param>
/// <param name="flow">
/// if true, align top edge to y. If false, align bottom edge
/// to y.
/// </param>
/// <param name="childrenLeft">Left edge where children should be positioned</param>
/// <param name="selected">Is this position selected?</param>
/// <param name="recycled">
/// Has this view been pulled from the recycle bin? If so it
/// does not need to be remeasured.
/// </param>
/// <param name="where">Where to add the item in the list</param>
private void setupChild(android.view.View child, int position, int y, bool flow,
int childrenLeft, bool selected, bool recycled, int where)
{
bool isSelected_1 = selected && shouldShowSelector();
bool updateChildSelected = isSelected_1 != child.isSelected();
int mode = mTouchMode;
bool isPressed_1 = mode > TOUCH_MODE_DOWN && mode < TOUCH_MODE_SCROLL && mMotionPosition
== position;
bool updateChildPressed = isPressed_1 != child.isPressed();
bool needToMeasure = !recycled || updateChildSelected || child.isLayoutRequested(
);
// Respect layout params that are already in the view. Otherwise make
// some up...
android.widget.AbsListView.LayoutParams p = (android.widget.AbsListView.LayoutParams
)child.getLayoutParams();
if (p == null)
{
p = new android.widget.AbsListView.LayoutParams(android.view.ViewGroup.LayoutParams
.MATCH_PARENT, android.view.ViewGroup.LayoutParams.WRAP_CONTENT, 0);
}
p.viewType = mAdapter.getItemViewType(position);
if (recycled && !p.forceAdd)
{
attachViewToParent(child, where, p);
}
else
{
p.forceAdd = false;
addViewInLayout(child, where, p, true);
}
if (updateChildSelected)
{
child.setSelected(isSelected_1);
if (isSelected_1)
{
requestFocus();
}
}
if (updateChildPressed)
{
child.setPressed(isPressed_1);
}
if (mChoiceMode != CHOICE_MODE_NONE && mCheckStates != null)
{
if (child is android.widget.Checkable)
{
((android.widget.Checkable)child).setChecked(mCheckStates.get(position));
}
else
{
if (getContext().getApplicationInfo().targetSdkVersion >= android.os.Build.VERSION_CODES
.HONEYCOMB)
{
child.setActivated(mCheckStates.get(position));
}
}
}
if (needToMeasure)
{
int childHeightSpec = android.view.ViewGroup.getChildMeasureSpec(android.view.View
.MeasureSpec.makeMeasureSpec(0, android.view.View.MeasureSpec.UNSPECIFIED), 0, p
.height);
int childWidthSpec = android.view.ViewGroup.getChildMeasureSpec(android.view.View
.MeasureSpec.makeMeasureSpec(mColumnWidth, android.view.View.MeasureSpec.EXACTLY
), 0, p.width);
child.measure(childWidthSpec, childHeightSpec);
}
else
{
cleanupLayoutState(child);
}
int w = child.getMeasuredWidth();
int h = child.getMeasuredHeight();
int childLeft;
int childTop = flow ? y : y - h;
int layoutDirection = getResolvedLayoutDirection();
int absoluteGravity = android.view.Gravity.getAbsoluteGravity(mGravity, layoutDirection
);
switch (absoluteGravity & android.view.Gravity.HORIZONTAL_GRAVITY_MASK)
{
case android.view.Gravity.LEFT:
{
childLeft = childrenLeft;
break;
}
case android.view.Gravity.CENTER_HORIZONTAL:
{
childLeft = childrenLeft + ((mColumnWidth - w) / 2);
break;
}
case android.view.Gravity.RIGHT:
{
childLeft = childrenLeft + mColumnWidth - w;
break;
}
default:
{
childLeft = childrenLeft;
break;
}
}
if (needToMeasure)
{
int childRight = childLeft + w;
int childBottom = childTop + h;
child.layout(childLeft, childTop, childRight, childBottom);
}
else
{
child.offsetLeftAndRight(childLeft - child.getLeft());
child.offsetTopAndBottom(childTop - child.getTop());
}
if (mCachingStarted)
{
child.setDrawingCacheEnabled(true);
}
if (recycled && (((android.widget.AbsListView.LayoutParams)child.getLayoutParams(
)).scrappedFromPosition) != position)
{
child.jumpDrawablesToCurrentState();
}
}