/*

* Copyright (C) 2006 The Android Open Source Project

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package android.widget;

import com.android.internal.R;

import android.annotation.IntDef;

import android.annotation.NonNull;

import android.annotation.Nullable;

import android.content.Context;

import android.content.res.TypedArray;

import android.graphics.Canvas;

import android.graphics.drawable.Drawable;

import android.util.AttributeSet;

import android.view.Gravity;

import android.view.View;

import android.view.ViewDebug;

import android.view.ViewGroup;

import android.view.ViewHierarchyEncoder;

import android.widget.RemoteViews.RemoteView;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

/**

* A Layout that arranges its children in a single column or a single row. The direction of

* the row can be set by calling {@link #setOrientation(int) setOrientation()}.

* You can also specify gravity, which specifies the alignment of all the child elements by

* calling {@link #setGravity(int) setGravity()} or specify that specific children

* grow to fill up any remaining space in the layout by setting the <em>weight</em> member of

* {@link android.widget.LinearLayout.LayoutParams LinearLayout.LayoutParams}.

* The default orientation is horizontal.

*

* <p>See the <a href="{@docRoot}guide/topics/ui/layout/linear.html">Linear Layout</a>

* guide.</p>

*

* <p>

* Also see {@link LinearLayout.LayoutParams android.widget.LinearLayout.LayoutParams}

* for layout attributes </p>

*

* @attr ref android.R.styleable#LinearLayout_baselineAligned

* @attr ref android.R.styleable#LinearLayout_baselineAlignedChildIndex

* @attr ref android.R.styleable#LinearLayout_gravity

* @attr ref android.R.styleable#LinearLayout_measureWithLargestChild

* @attr ref android.R.styleable#LinearLayout_orientation

* @attr ref android.R.styleable#LinearLayout_weightSum

*/

@RemoteView

public class LinearLayout extends ViewGroup {

/** @hide */

@IntDef({HORIZONTAL, VERTICAL})

@Retention(RetentionPolicy.SOURCE)

public @interface OrientationMode {}

public static final int HORIZONTAL = 0;

public static final int VERTICAL = 1;

/** @hide */

@IntDef(flag = true,

value = {

SHOW_DIVIDER_NONE,

SHOW_DIVIDER_BEGINNING,

SHOW_DIVIDER_MIDDLE,

SHOW_DIVIDER_END

})

@Retention(RetentionPolicy.SOURCE)

public @interface DividerMode {}

/**

* Don't show any dividers.

*/

public static final int SHOW_DIVIDER_NONE = 0;

/**

* Show a divider at the beginning of the group.

*/

public static final int SHOW_DIVIDER_BEGINNING = 1;

/**

* Show dividers between each item in the group.

*/

public static final int SHOW_DIVIDER_MIDDLE = 2;

/**

* Show a divider at the end of the group.

*/

public static final int SHOW_DIVIDER_END = 4;

/**

* Whether the children of this layout are baseline aligned. Only applicable

* if {@link #mOrientation} is horizontal.

*/

@ViewDebug.ExportedProperty(category = "layout")

private boolean mBaselineAligned = true;

/**

* If this layout is part of another layout that is baseline aligned,

* use the child at this index as the baseline.

*

* Note: this is orthogonal to {@link #mBaselineAligned}, which is concerned

* with whether the children of this layout are baseline aligned.

*/

@ViewDebug.ExportedProperty(category = "layout")

private int mBaselineAlignedChildIndex = -1;

/**

* The additional offset to the child's baseline.

* We'll calculate the baseline of this layout as we measure vertically; for

* horizontal linear layouts, the offset of 0 is appropriate.

*/

@ViewDebug.ExportedProperty(category = "measurement")

private int mBaselineChildTop = 0;

@ViewDebug.ExportedProperty(category = "measurement")

private int mOrientation;

@ViewDebug.ExportedProperty(category = "measurement", flagMapping = {

@ViewDebug.FlagToString(mask = -1,

equals = -1, name = "NONE"),

@ViewDebug.FlagToString(mask = Gravity.NO_GRAVITY,

equals = Gravity.NO_GRAVITY,name = "NONE"),

@ViewDebug.FlagToString(mask = Gravity.TOP,

equals = Gravity.TOP, name = "TOP"),

@ViewDebug.FlagToString(mask = Gravity.BOTTOM,

equals = Gravity.BOTTOM, name = "BOTTOM"),

@ViewDebug.FlagToString(mask = Gravity.LEFT,

equals = Gravity.LEFT, name = "LEFT"),

@ViewDebug.FlagToString(mask = Gravity.RIGHT,

equals = Gravity.RIGHT, name = "RIGHT"),

@ViewDebug.FlagToString(mask = Gravity.START,

equals = Gravity.START, name = "START"),

@ViewDebug.FlagToString(mask = Gravity.END,

equals = Gravity.END, name = "END"),

@ViewDebug.FlagToString(mask = Gravity.CENTER_VERTICAL,

equals = Gravity.CENTER_VERTICAL, name = "CENTER_VERTICAL"),

@ViewDebug.FlagToString(mask = Gravity.FILL_VERTICAL,

equals = Gravity.FILL_VERTICAL, name = "FILL_VERTICAL"),

@ViewDebug.FlagToString(mask = Gravity.CENTER_HORIZONTAL,

equals = Gravity.CENTER_HORIZONTAL, name = "CENTER_HORIZONTAL"),

@ViewDebug.FlagToString(mask = Gravity.FILL_HORIZONTAL,

equals = Gravity.FILL_HORIZONTAL, name = "FILL_HORIZONTAL"),

@ViewDebug.FlagToString(mask = Gravity.CENTER,

equals = Gravity.CENTER, name = "CENTER"),

@ViewDebug.FlagToString(mask = Gravity.FILL,

equals = Gravity.FILL, name = "FILL"),

@ViewDebug.FlagToString(mask = Gravity.RELATIVE_LAYOUT_DIRECTION,

equals = Gravity.RELATIVE_LAYOUT_DIRECTION, name = "RELATIVE")

}, formatToHexString = true)

private int mGravity = Gravity.START | Gravity.TOP;

@ViewDebug.ExportedProperty(category = "measurement")

private int mTotalLength;

@ViewDebug.ExportedProperty(category = "layout")

private float mWeightSum;

@ViewDebug.ExportedProperty(category = "layout")

private boolean mUseLargestChild;

private int[] mMaxAscent;

private int[] mMaxDescent;

private static final int VERTICAL_GRAVITY_COUNT = 4;

private static final int INDEX_CENTER_VERTICAL = 0;

private static final int INDEX_TOP = 1;

private static final int INDEX_BOTTOM = 2;

private static final int INDEX_FILL = 3;

private Drawable mDivider;

private int mDividerWidth;

private int mDividerHeight;

private int mShowDividers;

private int mDividerPadding;

private int mLayoutDirection = View.LAYOUT_DIRECTION_UNDEFINED;

public LinearLayout(Context context) {

this(context, null);

}

public LinearLayout(Context context, @Nullable AttributeSet attrs) {

this(context, attrs, 0);

}

public LinearLayout(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {

this(context, attrs, defStyleAttr, 0);

}

public LinearLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {

super(context, attrs, defStyleAttr, defStyleRes);

final TypedArray a = context.obtainStyledAttributes(

attrs, com.android.internal.R.styleable.LinearLayout, defStyleAttr, defStyleRes);

int index = a.getInt(com.android.internal.R.styleable.LinearLayout_orientation, -1);

if (index >= 0) {

setOrientation(index);

}

index = a.getInt(com.android.internal.R.styleable.LinearLayout_gravity, -1);

if (index >= 0) {

setGravity(index);

}

boolean baselineAligned = a.getBoolean(R.styleable.LinearLayout_baselineAligned, true);

if (!baselineAligned) {

setBaselineAligned(baselineAligned);

}

mWeightSum = a.getFloat(R.styleable.LinearLayout_weightSum, -1.0f);

mBaselineAlignedChildIndex =

a.getInt(com.android.internal.R.styleable.LinearLayout_baselineAlignedChildIndex, -1);

mUseLargestChild = a.getBoolean(R.styleable.LinearLayout_measureWithLargestChild, false);

setDividerDrawable(a.getDrawable(R.styleable.LinearLayout_divider));

mShowDividers = a.getInt(R.styleable.LinearLayout_showDividers, SHOW_DIVIDER_NONE);

mDividerPadding = a.getDimensionPixelSize(R.styleable.LinearLayout_dividerPadding, 0);

a.recycle();

}

/**

* Set how dividers should be shown between items in this layout

*

* @param showDividers One or more of {@link #SHOW_DIVIDER_BEGINNING},

* {@link #SHOW_DIVIDER_MIDDLE}, or {@link #SHOW_DIVIDER_END},

* or {@link #SHOW_DIVIDER_NONE} to show no dividers.

*/

public void setShowDividers(@DividerMode int showDividers) {

if (showDividers != mShowDividers) {

requestLayout();

}

mShowDividers = showDividers;

}

@Override

public boolean shouldDelayChildPressedState() {

return false;

}

/**

* @return A flag set indicating how dividers should be shown around items.

* @see #setShowDividers(int)

*/

@DividerMode

public int getShowDividers() {

return mShowDividers;

}

/**

* @return the divider Drawable that will divide each item.

*

* @see #setDividerDrawable(Drawable)

*

* @attr ref android.R.styleable#LinearLayout_divider

*/

public Drawable getDividerDrawable() {

return mDivider;

}

/**

* Set a drawable to be used as a divider between items.

*

* @param divider Drawable that will divide each item.

*

* @see #setShowDividers(int)

*

* @attr ref android.R.styleable#LinearLayout_divider

*/

public void setDividerDrawable(Drawable divider) {

if (divider == mDivider) {

return;

}

mDivider = divider;

if (divider != null) {

mDividerWidth = divider.getIntrinsicWidth();

mDividerHeight = divider.getIntrinsicHeight();

} else {

mDividerWidth = 0;

mDividerHeight = 0;

}

setWillNotDraw(divider == null);

requestLayout();

}

/**

* Set padding displayed on both ends of dividers.

*

* @param padding Padding value in pixels that will be applied to each end

*

* @see #setShowDividers(int)

* @see #setDividerDrawable(Drawable)

* @see #getDividerPadding()

*/

public void setDividerPadding(int padding) {

mDividerPadding = padding;

}

/**

* Get the padding size used to inset dividers in pixels

*

* @see #setShowDividers(int)

* @see #setDividerDrawable(Drawable)

* @see #setDividerPadding(int)

*/

public int getDividerPadding() {

return mDividerPadding;

}

/**

* Get the width of the current divider drawable.

*

* @hide Used internally by framework.

*/

public int getDividerWidth() {

return mDividerWidth;

}

@Override

protected void onDraw(Canvas canvas) {

if (mDivider == null) {

return;

}

if (mOrientation == VERTICAL) {

drawDividersVertical(canvas);

} else {

drawDividersHorizontal(canvas);

}

}

void drawDividersVertical(Canvas canvas) {

final int count = getVirtualChildCount();

for (int i = 0; i < count; i++) {

final View child = getVirtualChildAt(i);

if (child != null && child.getVisibility() != GONE) {

if (hasDividerBeforeChildAt(i)) {

final LayoutParams lp = (LayoutParams) child.getLayoutParams();

final int top = child.getTop() - lp.topMargin - mDividerHeight;

drawHorizontalDivider(canvas, top);

}

}

}

if (hasDividerBeforeChildAt(count)) {

final View child = getLastNonGoneChild();

int bottom = 0;

if (child == null) {

bottom = getHeight() - getPaddingBottom() - mDividerHeight;

} else {

final LayoutParams lp = (LayoutParams) child.getLayoutParams();

bottom = child.getBottom() + lp.bottomMargin;

}

drawHorizontalDivider(canvas, bottom);

}

}

/**

* Finds the last child that is not gone. The last child will be used as the reference for

* where the end divider should be drawn.

*/

private View getLastNonGoneChild() {

for (int i = getVirtualChildCount() - 1; i >= 0; i--) {

View child = getVirtualChildAt(i);

if (child != null && child.getVisibility() != GONE) {

return child;

}

}

return null;

}

void drawDividersHorizontal(Canvas canvas) {

final int count = getVirtualChildCount();

final boolean isLayoutRtl = isLayoutRtl();

for (int i = 0; i < count; i++) {

final View child = getVirtualChildAt(i);

if (child != null && child.getVisibility() != GONE) {

if (hasDividerBeforeChildAt(i)) {

final LayoutParams lp = (LayoutParams) child.getLayoutParams();

final int position;

if (isLayoutRtl) {

position = child.getRight() + lp.rightMargin;

} else {

position = child.getLeft() - lp.leftMargin - mDividerWidth;

}

drawVerticalDivider(canvas, position);

}

}

}

if (hasDividerBeforeChildAt(count)) {

final View child = getLastNonGoneChild();

int position;

if (child == null) {

if (isLayoutRtl) {

position = getPaddingLeft();

} else {

position = getWidth() - getPaddingRight() - mDividerWidth;

}

} else {

final LayoutParams lp = (LayoutParams) child.getLayoutParams();

if (isLayoutRtl) {

position = child.getLeft() - lp.leftMargin - mDividerWidth;

} else {

position = child.getRight() + lp.rightMargin;

}

}

drawVerticalDivider(canvas, position);

}

}

void drawHorizontalDivider(Canvas canvas, int top) {

mDivider.setBounds(getPaddingLeft() + mDividerPadding, top,

getWidth() - getPaddingRight() - mDividerPadding, top + mDividerHeight);

mDivider.draw(canvas);

}

void drawVerticalDivider(Canvas canvas, int left) {

mDivider.setBounds(left, getPaddingTop() + mDividerPadding,

left + mDividerWidth, getHeight() - getPaddingBottom() - mDividerPadding);

mDivider.draw(canvas);

}

/**

* <p>Indicates whether widgets contained within this layout are aligned

* on their baseline or not.</p>

*

* @return true when widgets are baseline-aligned, false otherwise

*/

public boolean isBaselineAligned() {

return mBaselineAligned;

}

/**

* <p>Defines whether widgets contained in this layout are

* baseline-aligned or not.</p>

*

* @param baselineAligned true to align widgets on their baseline,

* false otherwise

*

* @attr ref android.R.styleable#LinearLayout_baselineAligned

*/

@android.view.RemotableViewMethod

public void setBaselineAligned(boolean baselineAligned) {

mBaselineAligned = baselineAligned;

}

/**

* When true, all children with a weight will be considered having

* the minimum size of the largest child. If false, all children are

* measured normally.

*

* @return True to measure children with a weight using the minimum

* size of the largest child, false otherwise.

*

* @attr ref android.R.styleable#LinearLayout_measureWithLargestChild

*/

public boolean isMeasureWithLargestChildEnabled() {

return mUseLargestChild;

}

/**

* When set to true, all children with a weight will be considered having

* the minimum size of the largest child. If false, all children are

* measured normally.

*

* Disabled by default.

*

* @param enabled True to measure children with a weight using the

* minimum size of the largest child, false otherwise.

*

* @attr ref android.R.styleable#LinearLayout_measureWithLargestChild

*/

@android.view.RemotableViewMethod

public void setMeasureWithLargestChildEnabled(boolean enabled) {

mUseLargestChild = enabled;

}

@Override

public int getBaseline() {

if (mBaselineAlignedChildIndex < 0) {

return super.getBaseline();

}

if (getChildCount() <= mBaselineAlignedChildIndex) {

throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout "

+ "set to an index that is out of bounds.");

}

final View child = getChildAt(mBaselineAlignedChildIndex);

final int childBaseline = child.getBaseline();

if (childBaseline == -1) {

if (mBaselineAlignedChildIndex == 0) {

// this is just the default case, safe to return -1

return -1;

}

// the user picked an index that points to something that doesn't

// know how to calculate its baseline.

throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout "

+ "points to a View that doesn't know how to get its baseline.");

}

// TODO: This should try to take into account the virtual offsets

// (See getNextLocationOffset and getLocationOffset)

// We should add to childTop:

// sum([getNextLocationOffset(getChildAt(i)) / i < mBaselineAlignedChildIndex])

// and also add:

// getLocationOffset(child)

int childTop = mBaselineChildTop;

if (mOrientation == VERTICAL) {

final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;

if (majorGravity != Gravity.TOP) {

switch (majorGravity) {

case Gravity.BOTTOM:

childTop = mBottom - mTop - mPaddingBottom - mTotalLength;

break;

case Gravity.CENTER_VERTICAL:

childTop += ((mBottom - mTop - mPaddingTop - mPaddingBottom) -

mTotalLength) / 2;

break;

}

}

}

LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

return childTop + lp.topMargin + childBaseline;

}

/**

* @return The index of the child that will be used if this layout is

* part of a larger layout that is baseline aligned, or -1 if none has

* been set.

*/

public int getBaselineAlignedChildIndex() {

return mBaselineAlignedChildIndex;

}

/**

* @param i The index of the child that will be used if this layout is

* part of a larger layout that is baseline aligned.

*

* @attr ref android.R.styleable#LinearLayout_baselineAlignedChildIndex

*/

@android.view.RemotableViewMethod

public void setBaselineAlignedChildIndex(int i) {

if ((i < 0) || (i >= getChildCount())) {

throw new IllegalArgumentException("base aligned child index out "

+ "of range (0, " + getChildCount() + ")");

}

mBaselineAlignedChildIndex = i;

}

/**

* <p>Returns the view at the specified index. This method can be overriden

* to take into account virtual children. Refer to

* {@link android.widget.TableLayout} and {@link android.widget.TableRow}

* for an example.</p>

*

* @param index the child's index

* @return the child at the specified index

*/

View getVirtualChildAt(int index) {

return getChildAt(index);

}

/**

* <p>Returns the virtual number of children. This number might be different

* than the actual number of children if the layout can hold virtual

* children. Refer to

* {@link android.widget.TableLayout} and {@link android.widget.TableRow}

* for an example.</p>

*

* @return the virtual number of children

*/

int getVirtualChildCount() {

return getChildCount();

}

/**

* Returns the desired weights sum.

*

* @return A number greater than 0.0f if the weight sum is defined, or

* a number lower than or equals to 0.0f if not weight sum is

* to be used.

*/

public float getWeightSum() {

return mWeightSum;

}

/**

* Defines the desired weights sum. If unspecified the weights sum is computed

* at layout time by adding the layout_weight of each child.

*

* This can be used for instance to give a single child 50% of the total

* available space by giving it a layout_weight of 0.5 and setting the

* weightSum to 1.0.

*

* @param weightSum a number greater than 0.0f, or a number lower than or equals

* to 0.0f if the weight sum should be computed from the children's

* layout_weight

*/

@android.view.RemotableViewMethod

public void setWeightSum(float weightSum) {

mWeightSum = Math.max(0.0f, weightSum);

}

@Override

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

if (mOrientation == VERTICAL) {

measureVertical(widthMeasureSpec, heightMeasureSpec);

} else {

measureHorizontal(widthMeasureSpec, heightMeasureSpec);

}

}

/**

* Determines where to position dividers between children.

*

* @param childIndex Index of child to check for preceding divider

* @return true if there should be a divider before the child at childIndex

* @hide Pending API consideration. Currently only used internally by the system.

*/

protected boolean hasDividerBeforeChildAt(int childIndex) {

if (childIndex == getVirtualChildCount()) {

// Check whether the end divider should draw.

return (mShowDividers & SHOW_DIVIDER_END) != 0;

}

boolean allViewsAreGoneBefore = allViewsAreGoneBefore(childIndex);

if (allViewsAreGoneBefore) {

// This is the first view that's not gone, check if beginning divider is enabled.

return (mShowDividers & SHOW_DIVIDER_BEGINNING) != 0;

} else {

return (mShowDividers & SHOW_DIVIDER_MIDDLE) != 0;

}

}

/**

* Checks whether all (virtual) child views before the given index are gone.

*/

private boolean allViewsAreGoneBefore(int childIndex) {

for (int i = childIndex - 1; i >= 0; i--) {

View child = getVirtualChildAt(i);

if (child != null && child.getVisibility() != GONE) {

return false;

}

}

return true;

}

/**

* Measures the children when the orientation of this LinearLayout is set

* to {@link #VERTICAL}.

*

* @param widthMeasureSpec Horizontal space requirements as imposed by the parent.

* @param heightMeasureSpec Vertical space requirements as imposed by the parent.

*

* @see #getOrientation()

* @see #setOrientation(int)

* @see #onMeasure(int, int)

*/

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {

mTotalLength = 0;

int maxWidth = 0;

int childState = 0;

int alternativeMaxWidth = 0;

int weightedMaxWidth = 0;

boolean allFillParent = true;

float totalWeight = 0;

final int count = getVirtualChildCount();

final int widthMode = MeasureSpec.getMode(widthMeasureSpec);

final int heightMode = MeasureSpec.getMode(heightMeasureSpec);

boolean matchWidth = false;

boolean skippedMeasure = false;

final int baselineChildIndex = mBaselineAlignedChildIndex;

final boolean useLargestChild = mUseLargestChild;

int largestChildHeight = Integer.MIN_VALUE;

// See how tall everyone is. Also remember max width.

for (int i = 0; i < count; ++i) {

final View child = getVirtualChildAt(i);

if (child == null) {

mTotalLength += measureNullChild(i);

continue;

}

if (child.getVisibility() == View.GONE) {

i += getChildrenSkipCount(child, i);

continue;

}

if (hasDividerBeforeChildAt(i)) {

mTotalLength += mDividerHeight;

}

LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

totalWeight += lp.weight;

if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {

// Optimization: don't bother measuring children who are going to use

// leftover space. These views will get measured again down below if

// there is any leftover space.

final int totalLength = mTotalLength;

mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);

skippedMeasure = true;

} else {

int oldHeight = Integer.MIN_VALUE;

if (lp.height == 0 && lp.weight > 0) {

// heightMode is either UNSPECIFIED or AT_MOST, and this

// child wanted to stretch to fill available space.

// Translate that to WRAP_CONTENT so that it does not end up

// with a height of 0

oldHeight = 0;

lp.height = LayoutParams.WRAP_CONTENT;

}

// Determine how big this child would like to be. If this or

// previous children have given a weight, then we allow it to

// use all available space (and we will shrink things later

// if needed).

measureChildBeforeLayout(

child, i, widthMeasureSpec, 0, heightMeasureSpec,

totalWeight == 0 ? mTotalLength : 0);

if (oldHeight != Integer.MIN_VALUE) {

lp.height = oldHeight;

}

final int childHeight = child.getMeasuredHeight();

final int totalLength = mTotalLength;

mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +

lp.bottomMargin + getNextLocationOffset(child));

if (useLargestChild) {

largestChildHeight = Math.max(childHeight, largestChildHeight);

}

}

/**

* If applicable, compute the additional offset to the child's baseline

* we'll need later when asked {@link #getBaseline}.

*/

if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {

mBaselineChildTop = mTotalLength;

}

// if we are trying to use a child index for our baseline, the above

// book keeping only works if there are no children above it with

// weight. fail fast to aid the developer.

if (i < baselineChildIndex && lp.weight > 0) {

throw new RuntimeException("A child of LinearLayout with index "

+ "less than mBaselineAlignedChildIndex has weight > 0, which "

+ "won't work. Either remove the weight, or don't set "

+ "mBaselineAlignedChildIndex.");

}

boolean matchWidthLocally = false;

if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {

// The width of the linear layout will scale, and at least one

// child said it wanted to match our width. Set a flag

// indicating that we need to remeasure at least that view when

// we know our width.

matchWidth = true;

matchWidthLocally = true;

}

final int margin = lp.leftMargin + lp.rightMargin;

final int measuredWidth = child.getMeasuredWidth() + margin;

maxWidth = Math.max(maxWidth, measuredWidth);

childState = combineMeasuredStates(childState, child.getMeasuredState());

allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;

if (lp.weight > 0) {

/*

* Widths of weighted Views are bogus if we end up

* remeasuring, so keep them separate.

*/

weightedMaxWidth = Math.max(weightedMaxWidth,

matchWidthLocally ? margin : measuredWidth);

} else {

alternativeMaxWidth = Math.max(alternativeMaxWidth,

matchWidthLocally ? margin : measuredWidth);

}

i += getChildrenSkipCount(child, i);

}

if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) {

mTotalLength += mDividerHeight;

}

if (useLargestChild &&

(heightMode == MeasureSpec.AT_MOST || heightMode == MeasureSpec.UNSPECIFIED)) {

mTotalLength = 0;

for (int i = 0; i < count; ++i) {

final View child = getVirtualChildAt(i);

if (child == null) {

mTotalLength += measureNullChild(i);

continue;

}

if (child.getVisibility() == GONE) {

i += getChildrenSkipCount(child, i);

continue;

}

final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)

child.getLayoutParams();

// Account for negative margins

final int totalLength = mTotalLength;

mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +

lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));

}

}

// Add in our padding

mTotalLength += mPaddingTop + mPaddingBottom;

int heightSize = mTotalLength;

// Check against our minimum height

heightSize = Math.max(heightSize, getSuggestedMinimumHeight());

// Reconcile our calculated size with the heightMeasureSpec

int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);

heightSize = heightSizeAndState & MEASURED_SIZE_MASK;

// Either expand children with weight to take up available space or

// shrink them if they extend beyond our current bounds. If we skipped

// measurement on any children, we need to measure them now.

int delta = heightSize - mTotalLength;

if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {

float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;

mTotalLength = 0;

for (int i = 0; i < count; ++i) {

final View child = getVirtualChildAt(i);

if (child.getVisibility() == View.GONE) {

continue;

}

LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();

float childExtra = lp.weight;

if (childExtra > 0) {

// Child said it could absorb extra space -- give him his share

int share = (int) (childExtra * delta / weightSum);

weightSum -= childExtra;

delta -= share;

final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,

mPaddingLeft + mPaddingRight +

lp.leftMargin + lp.rightMargin, lp.width);

// TODO: Use a field like lp.isMeasured to figure out if this

// child has been previously measured

if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {

// child was measured once already above...

// base new measurement on stored values

int childHeight = child.getMeasuredHeight() + share;

if (childHeight < 0) {

childHeight = 0;

}

child.measure(childWidthMeasureSpec,

MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));

} else {

// child was skipped in the loop above.

// Measure for this first time here

child.measure(childWidthMeasureSpec,

MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,

MeasureSpec.EXACTLY));

}

// Child may now not fit in vertical dimension.

childState = combineMeasuredStates(childState, child.getMeasuredState()

& (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));

}

final int margin = lp.leftMargin + lp.rightMargin;

final int measuredWidth = child.getMeasuredWidth() + margin;

maxWidth = Math.max(maxWidth, measuredWidth);

boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&

lp.width == LayoutParams.MATCH_PARENT;

alternativeMaxWidth = Math.max(alternativeMaxWidth,

matchWidthLocally ? margin : measuredWidth);

allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;

final int totalLength = mTotalLength;

mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +

lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));

}

// Add in our padding

mTotalLength += mPaddingTop + mPaddingBottom;

// TODO: Should we recompute the heightSpec based on the new total length?

} else {

alternativeMaxWidth = Math.max(alternativeMaxWidth,

weightedMaxWidth);

// We have no limit, so make all weighted views as tall as the largest child.

// Children will have already been measured once.

if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {

for (int i = 0; i < count; i++) {

final View child = getVirtualChildAt(i);

if (child == null || child.getVisibility() == View.GONE) {

continue;

}

final LinearLayout.LayoutParams lp =

(LinearLayout.LayoutParams) child.getLayoutParams();

float childExtra = lp.weight;

if (childExtra > 0) {

child.measure(

MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),

MeasureSpec.EXACTLY),

MeasureSpec.makeMeasureSpec(largestChildHeight,

MeasureSpec.EXACTLY));

}

}

}

}

if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {

maxWidth = alternativeMaxWidth;

}

maxWidth += mPaddingLeft + mPaddingRight;

// Check against our minimum width

maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),

heightSizeAndState);

if (matchWidth) {

forceUniformWidth(count, heightMeasureSpec);

}

}

private void forceUniformWidth(int count, int heightMeasureSpec) {

// Pretend that the linear layout has an exact size.

int uniformMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth(),

MeasureSpec.EXACTLY);

for (int i = 0; i< count; ++i) {

final View child = getVirtualChildAt(i);

if (child.getVisibility() != GONE) {

LinearLayout.LayoutParams lp = ((LinearLayout.LayoutParams)child.getLayoutParams());

if (lp.width == LayoutParams.MATCH_PARENT) {

// Temporarily force children to reuse their old measured height

// FIXME: this may not be right for something like wrapping text?

int oldHeight = lp.height;

lp.height = child.getMeasuredHeight();

// Remeasue with new dimensions

measureChildWithMargins(child, uniformMeasureSpec, 0, heightMeasureSpec, 0);

lp.height = oldHeight;

}

}

}

}