| /* |
| * Copyright (C) 2014 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 androidx.appcompat.widget; |
| |
| import static androidx.annotation.RestrictTo.Scope.LIBRARY; |
| import static androidx.annotation.RestrictTo.Scope.LIBRARY_GROUP_PREFIX; |
| |
| import android.content.Context; |
| import android.graphics.Canvas; |
| import android.graphics.drawable.Drawable; |
| import android.util.AttributeSet; |
| import android.view.Gravity; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.accessibility.AccessibilityNodeInfo; |
| import android.widget.LinearLayout; |
| |
| import androidx.annotation.IntDef; |
| import androidx.annotation.NonNull; |
| import androidx.annotation.Nullable; |
| import androidx.annotation.RestrictTo; |
| import androidx.appcompat.R; |
| import androidx.core.view.GravityCompat; |
| import androidx.core.view.ViewCompat; |
| |
| 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 LinearLayoutCompat.LayoutParams LinearLayoutCompat.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 LinearLayoutCompat.LayoutParams} for layout attributes </p> |
| */ |
| public class LinearLayoutCompat extends ViewGroup { |
| /** @hide */ |
| @RestrictTo(LIBRARY_GROUP_PREFIX) |
| @IntDef({HORIZONTAL, VERTICAL}) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface OrientationMode {} |
| |
| public static final int HORIZONTAL = 0; |
| public static final int VERTICAL = 1; |
| |
| /** @hide */ |
| @RestrictTo(LIBRARY_GROUP_PREFIX) |
| @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. |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| private int mBaselineChildTop = 0; |
| |
| private int mOrientation; |
| |
| private int mGravity = GravityCompat.START | Gravity.TOP; |
| |
| private int mTotalLength; |
| |
| private float mWeightSum; |
| |
| 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; |
| |
| /** Class name may be obfuscated by Proguard. Hardcode the string for accessibility usage. */ |
| private static final String ACCESSIBILITY_CLASS_NAME = |
| "androidx.appcompat.widget.LinearLayoutCompat"; |
| |
| private Drawable mDivider; |
| private int mDividerWidth; |
| private int mDividerHeight; |
| private int mShowDividers; |
| private int mDividerPadding; |
| |
| public LinearLayoutCompat(@NonNull Context context) { |
| this(context, null); |
| } |
| |
| public LinearLayoutCompat(@NonNull Context context, @Nullable AttributeSet attrs) { |
| this(context, attrs, 0); |
| } |
| |
| public LinearLayoutCompat( |
| @NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) { |
| super(context, attrs, defStyleAttr); |
| |
| final TintTypedArray a = TintTypedArray.obtainStyledAttributes(context, attrs, |
| R.styleable.LinearLayoutCompat, defStyleAttr, 0); |
| ViewCompat.saveAttributeDataForStyleable(this, |
| context, R.styleable.LinearLayoutCompat, attrs, |
| a.getWrappedTypeArray(), defStyleAttr, 0); |
| |
| int index = a.getInt(R.styleable.LinearLayoutCompat_android_orientation, -1); |
| if (index >= 0) { |
| setOrientation(index); |
| } |
| |
| index = a.getInt(R.styleable.LinearLayoutCompat_android_gravity, -1); |
| if (index >= 0) { |
| setGravity(index); |
| } |
| |
| boolean baselineAligned = a.getBoolean(R.styleable.LinearLayoutCompat_android_baselineAligned, true); |
| if (!baselineAligned) { |
| setBaselineAligned(baselineAligned); |
| } |
| |
| mWeightSum = a.getFloat(R.styleable.LinearLayoutCompat_android_weightSum, -1.0f); |
| |
| mBaselineAlignedChildIndex = |
| a.getInt(R.styleable.LinearLayoutCompat_android_baselineAlignedChildIndex, -1); |
| |
| mUseLargestChild = a.getBoolean(R.styleable.LinearLayoutCompat_measureWithLargestChild, false); |
| |
| setDividerDrawable(a.getDrawable(R.styleable.LinearLayoutCompat_divider)); |
| mShowDividers = a.getInt(R.styleable.LinearLayoutCompat_showDividers, SHOW_DIVIDER_NONE); |
| mDividerPadding = a.getDimensionPixelSize(R.styleable.LinearLayoutCompat_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) |
| */ |
| 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) |
| */ |
| 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. |
| */ |
| @RestrictTo(LIBRARY_GROUP_PREFIX) |
| 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 = getVirtualChildAt(count - 1); |
| 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); |
| } |
| } |
| |
| void drawDividersHorizontal(Canvas canvas) { |
| final int count = getVirtualChildCount(); |
| final boolean isLayoutRtl = ViewUtils.isLayoutRtl(this); |
| 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 = getVirtualChildAt(count - 1); |
| 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 |
| */ |
| 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. |
| */ |
| 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. |
| */ |
| 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 = getBottom() - getTop() - getPaddingBottom() - mTotalLength; |
| break; |
| |
| case Gravity.CENTER_VERTICAL: |
| childTop += ((getBottom() - getTop() - getPaddingTop() - getPaddingBottom()) - |
| mTotalLength) / 2; |
| break; |
| } |
| } |
| } |
| |
| LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.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. |
| */ |
| 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 overridden |
| * 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 |
| */ |
| 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. |
| */ |
| @RestrictTo(LIBRARY) |
| protected boolean hasDividerBeforeChildAt(int childIndex) { |
| if (childIndex == 0) { |
| return (mShowDividers & SHOW_DIVIDER_BEGINNING) != 0; |
| } else if (childIndex == getChildCount()) { |
| return (mShowDividers & SHOW_DIVIDER_END) != 0; |
| } else if ((mShowDividers & SHOW_DIVIDER_MIDDLE) != 0) { |
| boolean hasVisibleViewBefore = false; |
| for (int i = childIndex - 1; i >= 0; i--) { |
| if (getChildAt(i).getVisibility() != GONE) { |
| hasVisibleViewBefore = true; |
| break; |
| } |
| } |
| return hasVisibleViewBefore; |
| } |
| return false; |
| } |
| |
| /** |
| * 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 = 0; |
| |
| // 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; |
| } |
| |
| LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.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 = View.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 LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.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 += getPaddingTop() + getPaddingBottom(); |
| |
| int heightSize = mTotalLength; |
| |
| // Check against our minimum height |
| heightSize = Math.max(heightSize, getSuggestedMinimumHeight()); |
| |
| // Reconcile our calculated size with the heightMeasureSpec |
| int heightSizeAndState = View.resolveSizeAndState(heightSize, heightMeasureSpec, 0); |
| heightSize = heightSizeAndState & View.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; |
| } |
| |
| LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| float childExtra = lp.weight; |
| if (childExtra > 0) { |
| // Child said it could absorb extra space -- give them their share |
| int share = (int) (childExtra * delta / weightSum); |
| weightSum -= childExtra; |
| delta -= share; |
| |
| final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, |
| getPaddingLeft() + getPaddingRight() + |
| 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 = View.combineMeasuredStates(childState, |
| child.getMeasuredState() & (View.MEASURED_STATE_MASK |
| >> View.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 += getPaddingTop() + getPaddingBottom(); |
| // 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 LinearLayoutCompat.LayoutParams lp = |
| (LinearLayoutCompat.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 += getPaddingLeft() + getPaddingRight(); |
| |
| // Check against our minimum width |
| maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth()); |
| |
| setMeasuredDimension(View.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) { |
| LinearLayoutCompat.LayoutParams lp = ((LinearLayoutCompat.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; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Measures the children when the orientation of this LinearLayout is set |
| * to {@link #HORIZONTAL}. |
| * |
| * @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 measureHorizontal(int widthMeasureSpec, int heightMeasureSpec) { |
| mTotalLength = 0; |
| int maxHeight = 0; |
| int childState = 0; |
| int alternativeMaxHeight = 0; |
| int weightedMaxHeight = 0; |
| boolean allFillParent = true; |
| float totalWeight = 0; |
| |
| final int count = getVirtualChildCount(); |
| |
| final int widthMode = MeasureSpec.getMode(widthMeasureSpec); |
| final int heightMode = MeasureSpec.getMode(heightMeasureSpec); |
| |
| boolean matchHeight = false; |
| boolean skippedMeasure = false; |
| |
| if (mMaxAscent == null || mMaxDescent == null) { |
| mMaxAscent = new int[VERTICAL_GRAVITY_COUNT]; |
| mMaxDescent = new int[VERTICAL_GRAVITY_COUNT]; |
| } |
| |
| final int[] maxAscent = mMaxAscent; |
| final int[] maxDescent = mMaxDescent; |
| |
| maxAscent[0] = maxAscent[1] = maxAscent[2] = maxAscent[3] = -1; |
| maxDescent[0] = maxDescent[1] = maxDescent[2] = maxDescent[3] = -1; |
| |
| final boolean baselineAligned = mBaselineAligned; |
| final boolean useLargestChild = mUseLargestChild; |
| |
| final boolean isExactly = widthMode == MeasureSpec.EXACTLY; |
| |
| int largestChildWidth = 0; |
| |
| // See how wide everyone is. Also remember max height. |
| 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; |
| } |
| |
| if (hasDividerBeforeChildAt(i)) { |
| mTotalLength += mDividerWidth; |
| } |
| |
| final LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.LayoutParams) |
| child.getLayoutParams(); |
| |
| totalWeight += lp.weight; |
| |
| if (widthMode == MeasureSpec.EXACTLY && lp.width == 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. |
| if (isExactly) { |
| mTotalLength += lp.leftMargin + lp.rightMargin; |
| } else { |
| final int totalLength = mTotalLength; |
| mTotalLength = Math.max(totalLength, totalLength + |
| lp.leftMargin + lp.rightMargin); |
| } |
| |
| // Baseline alignment requires to measure widgets to obtain the |
| // baseline offset (in particular for TextViews). The following |
| // defeats the optimization mentioned above. Allow the child to |
| // use as much space as it wants because we can shrink things |
| // later (and re-measure). |
| if (baselineAligned) { |
| final int freeSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED); |
| child.measure(freeSpec, freeSpec); |
| } else { |
| skippedMeasure = true; |
| } |
| } else { |
| int oldWidth = Integer.MIN_VALUE; |
| |
| if (lp.width == 0 && lp.weight > 0) { |
| // widthMode 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 width of 0 |
| oldWidth = 0; |
| lp.width = 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, |
| totalWeight == 0 ? mTotalLength : 0, |
| heightMeasureSpec, 0); |
| |
| if (oldWidth != Integer.MIN_VALUE) { |
| lp.width = oldWidth; |
| } |
| |
| final int childWidth = child.getMeasuredWidth(); |
| if (isExactly) { |
| mTotalLength += childWidth + lp.leftMargin + lp.rightMargin + |
| getNextLocationOffset(child); |
| } else { |
| final int totalLength = mTotalLength; |
| mTotalLength = Math.max(totalLength, totalLength + childWidth + lp.leftMargin + |
| lp.rightMargin + getNextLocationOffset(child)); |
| } |
| |
| if (useLargestChild) { |
| largestChildWidth = Math.max(childWidth, largestChildWidth); |
| } |
| } |
| |
| boolean matchHeightLocally = false; |
| if (heightMode != MeasureSpec.EXACTLY && lp.height == LayoutParams.MATCH_PARENT) { |
| // The height of the linear layout will scale, and at least one |
| // child said it wanted to match our height. Set a flag indicating that |
| // we need to remeasure at least that view when we know our height. |
| matchHeight = true; |
| matchHeightLocally = true; |
| } |
| |
| final int margin = lp.topMargin + lp.bottomMargin; |
| final int childHeight = child.getMeasuredHeight() + margin; |
| childState = View.combineMeasuredStates(childState, child.getMeasuredState()); |
| |
| if (baselineAligned) { |
| final int childBaseline = child.getBaseline(); |
| if (childBaseline != -1) { |
| // Translates the child's vertical gravity into an index |
| // in the range 0..VERTICAL_GRAVITY_COUNT |
| final int gravity = (lp.gravity < 0 ? mGravity : lp.gravity) |
| & Gravity.VERTICAL_GRAVITY_MASK; |
| final int index = ((gravity >> Gravity.AXIS_Y_SHIFT) |
| & ~Gravity.AXIS_SPECIFIED) >> 1; |
| |
| maxAscent[index] = Math.max(maxAscent[index], childBaseline); |
| maxDescent[index] = Math.max(maxDescent[index], childHeight - childBaseline); |
| } |
| } |
| |
| maxHeight = Math.max(maxHeight, childHeight); |
| |
| allFillParent = allFillParent && lp.height == LayoutParams.MATCH_PARENT; |
| if (lp.weight > 0) { |
| /* |
| * Heights of weighted Views are bogus if we end up |
| * remeasuring, so keep them separate. |
| */ |
| weightedMaxHeight = Math.max(weightedMaxHeight, |
| matchHeightLocally ? margin : childHeight); |
| } else { |
| alternativeMaxHeight = Math.max(alternativeMaxHeight, |
| matchHeightLocally ? margin : childHeight); |
| } |
| |
| i += getChildrenSkipCount(child, i); |
| } |
| |
| if (mTotalLength > 0 && hasDividerBeforeChildAt(count)) { |
| mTotalLength += mDividerWidth; |
| } |
| |
| // Check mMaxAscent[INDEX_TOP] first because it maps to Gravity.TOP, |
| // the most common case |
| if (maxAscent[INDEX_TOP] != -1 || |
| maxAscent[INDEX_CENTER_VERTICAL] != -1 || |
| maxAscent[INDEX_BOTTOM] != -1 || |
| maxAscent[INDEX_FILL] != -1) { |
| final int ascent = Math.max(maxAscent[INDEX_FILL], |
| Math.max(maxAscent[INDEX_CENTER_VERTICAL], |
| Math.max(maxAscent[INDEX_TOP], maxAscent[INDEX_BOTTOM]))); |
| final int descent = Math.max(maxDescent[INDEX_FILL], |
| Math.max(maxDescent[INDEX_CENTER_VERTICAL], |
| Math.max(maxDescent[INDEX_TOP], maxDescent[INDEX_BOTTOM]))); |
| maxHeight = Math.max(maxHeight, ascent + descent); |
| } |
| |
| if (useLargestChild && |
| (widthMode == MeasureSpec.AT_MOST || widthMode == 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 LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.LayoutParams) |
| child.getLayoutParams(); |
| if (isExactly) { |
| mTotalLength += largestChildWidth + lp.leftMargin + lp.rightMargin + |
| getNextLocationOffset(child); |
| } else { |
| final int totalLength = mTotalLength; |
| mTotalLength = Math.max(totalLength, totalLength + largestChildWidth + |
| lp.leftMargin + lp.rightMargin + getNextLocationOffset(child)); |
| } |
| } |
| } |
| |
| // Add in our padding |
| mTotalLength += getPaddingLeft() + getPaddingRight(); |
| |
| int widthSize = mTotalLength; |
| |
| // Check against our minimum width |
| widthSize = Math.max(widthSize, getSuggestedMinimumWidth()); |
| |
| // Reconcile our calculated size with the widthMeasureSpec |
| int widthSizeAndState = View.resolveSizeAndState(widthSize, widthMeasureSpec, 0); |
| widthSize = widthSizeAndState & View.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 = widthSize - mTotalLength; |
| if (skippedMeasure || (delta != 0 && totalWeight > 0.0f)) { |
| float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight; |
| |
| maxAscent[0] = maxAscent[1] = maxAscent[2] = maxAscent[3] = -1; |
| maxDescent[0] = maxDescent[1] = maxDescent[2] = maxDescent[3] = -1; |
| maxHeight = -1; |
| |
| mTotalLength = 0; |
| |
| for (int i = 0; i < count; ++i) { |
| final View child = getVirtualChildAt(i); |
| |
| if (child == null || child.getVisibility() == View.GONE) { |
| continue; |
| } |
| |
| final LinearLayoutCompat.LayoutParams lp = |
| (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| float childExtra = lp.weight; |
| if (childExtra > 0) { |
| // Child said it could absorb extra space -- give them their share |
| int share = (int) (childExtra * delta / weightSum); |
| weightSum -= childExtra; |
| delta -= share; |
| |
| final int childHeightMeasureSpec = getChildMeasureSpec( |
| heightMeasureSpec, |
| getPaddingTop() + getPaddingBottom() + lp.topMargin + lp.bottomMargin, |
| lp.height); |
| |
| // TODO: Use a field like lp.isMeasured to figure out if this |
| // child has been previously measured |
| if ((lp.width != 0) || (widthMode != MeasureSpec.EXACTLY)) { |
| // child was measured once already above ... base new measurement |
| // on stored values |
| int childWidth = child.getMeasuredWidth() + share; |
| if (childWidth < 0) { |
| childWidth = 0; |
| } |
| |
| child.measure( |
| MeasureSpec.makeMeasureSpec(childWidth, MeasureSpec.EXACTLY), |
| childHeightMeasureSpec); |
| } else { |
| // child was skipped in the loop above. Measure for this first time here |
| child.measure(MeasureSpec.makeMeasureSpec( |
| share > 0 ? share : 0, MeasureSpec.EXACTLY), |
| childHeightMeasureSpec); |
| } |
| |
| // Child may now not fit in horizontal dimension. |
| childState = View.combineMeasuredStates(childState, |
| child.getMeasuredState() & View.MEASURED_STATE_MASK); |
| } |
| |
| if (isExactly) { |
| mTotalLength += child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin + |
| getNextLocationOffset(child); |
| } else { |
| final int totalLength = mTotalLength; |
| mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredWidth() + |
| lp.leftMargin + lp.rightMargin + getNextLocationOffset(child)); |
| } |
| |
| boolean matchHeightLocally = heightMode != MeasureSpec.EXACTLY && |
| lp.height == LayoutParams.MATCH_PARENT; |
| |
| final int margin = lp.topMargin + lp .bottomMargin; |
| int childHeight = child.getMeasuredHeight() + margin; |
| maxHeight = Math.max(maxHeight, childHeight); |
| alternativeMaxHeight = Math.max(alternativeMaxHeight, |
| matchHeightLocally ? margin : childHeight); |
| |
| allFillParent = allFillParent && lp.height == LayoutParams.MATCH_PARENT; |
| |
| if (baselineAligned) { |
| final int childBaseline = child.getBaseline(); |
| if (childBaseline != -1) { |
| // Translates the child's vertical gravity into an index in the range 0..2 |
| final int gravity = (lp.gravity < 0 ? mGravity : lp.gravity) |
| & Gravity.VERTICAL_GRAVITY_MASK; |
| final int index = ((gravity >> Gravity.AXIS_Y_SHIFT) |
| & ~Gravity.AXIS_SPECIFIED) >> 1; |
| |
| maxAscent[index] = Math.max(maxAscent[index], childBaseline); |
| maxDescent[index] = Math.max(maxDescent[index], |
| childHeight - childBaseline); |
| } |
| } |
| } |
| |
| // Add in our padding |
| mTotalLength += getPaddingLeft() + getPaddingRight(); |
| // TODO: Should we update widthSize with the new total length? |
| |
| // Check mMaxAscent[INDEX_TOP] first because it maps to Gravity.TOP, |
| // the most common case |
| if (maxAscent[INDEX_TOP] != -1 || |
| maxAscent[INDEX_CENTER_VERTICAL] != -1 || |
| maxAscent[INDEX_BOTTOM] != -1 || |
| maxAscent[INDEX_FILL] != -1) { |
| final int ascent = Math.max(maxAscent[INDEX_FILL], |
| Math.max(maxAscent[INDEX_CENTER_VERTICAL], |
| Math.max(maxAscent[INDEX_TOP], maxAscent[INDEX_BOTTOM]))); |
| final int descent = Math.max(maxDescent[INDEX_FILL], |
| Math.max(maxDescent[INDEX_CENTER_VERTICAL], |
| Math.max(maxDescent[INDEX_TOP], maxDescent[INDEX_BOTTOM]))); |
| maxHeight = Math.max(maxHeight, ascent + descent); |
| } |
| } else { |
| alternativeMaxHeight = Math.max(alternativeMaxHeight, weightedMaxHeight); |
| |
| // We have no limit, so make all weighted views as wide as the largest child. |
| // Children will have already been measured once. |
| if (useLargestChild && widthMode != MeasureSpec.EXACTLY) { |
| for (int i = 0; i < count; i++) { |
| final View child = getVirtualChildAt(i); |
| |
| if (child == null || child.getVisibility() == View.GONE) { |
| continue; |
| } |
| |
| final LinearLayoutCompat.LayoutParams lp = |
| (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| float childExtra = lp.weight; |
| if (childExtra > 0) { |
| child.measure( |
| MeasureSpec.makeMeasureSpec(largestChildWidth, MeasureSpec.EXACTLY), |
| MeasureSpec.makeMeasureSpec(child.getMeasuredHeight(), |
| MeasureSpec.EXACTLY)); |
| } |
| } |
| } |
| } |
| |
| if (!allFillParent && heightMode != MeasureSpec.EXACTLY) { |
| maxHeight = alternativeMaxHeight; |
| } |
| |
| maxHeight += getPaddingTop() + getPaddingBottom(); |
| |
| // Check against our minimum height |
| maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight()); |
| |
| setMeasuredDimension(widthSizeAndState | (childState & View.MEASURED_STATE_MASK), |
| View.resolveSizeAndState(maxHeight, heightMeasureSpec, |
| (childState << View.MEASURED_HEIGHT_STATE_SHIFT))); |
| |
| if (matchHeight) { |
| forceUniformHeight(count, widthMeasureSpec); |
| } |
| } |
| |
| private void forceUniformHeight(int count, int widthMeasureSpec) { |
| // Pretend that the linear layout has an exact size. This is the measured height of |
| // ourselves. The measured height should be the max height of the children, changed |
| // to accommodate the heightMeasureSpec from the parent |
| int uniformMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight(), |
| MeasureSpec.EXACTLY); |
| for (int i = 0; i < count; ++i) { |
| final View child = getVirtualChildAt(i); |
| if (child.getVisibility() != GONE) { |
| LinearLayoutCompat.LayoutParams lp = (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| if (lp.height == LayoutParams.MATCH_PARENT) { |
| // Temporarily force children to reuse their old measured width |
| // FIXME: this may not be right for something like wrapping text? |
| int oldWidth = lp.width; |
| lp.width = child.getMeasuredWidth(); |
| |
| // Remeasure with new dimensions |
| measureChildWithMargins(child, widthMeasureSpec, 0, uniformMeasureSpec, 0); |
| lp.width = oldWidth; |
| } |
| } |
| } |
| } |
| |
| /** |
| * <p>Returns the number of children to skip after measuring/laying out |
| * the specified child.</p> |
| * |
| * @param child the child after which we want to skip children |
| * @param index the index of the child after which we want to skip children |
| * @return the number of children to skip, 0 by default |
| */ |
| int getChildrenSkipCount(View child, int index) { |
| return 0; |
| } |
| |
| /** |
| * <p>Returns the size (width or height) that should be occupied by a null |
| * child.</p> |
| * |
| * @param childIndex the index of the null child |
| * @return the width or height of the child depending on the orientation |
| */ |
| int measureNullChild(int childIndex) { |
| return 0; |
| } |
| |
| /** |
| * <p>Measure the child according to the parent's measure specs. This |
| * method should be overridden by subclasses to force the sizing of |
| * children. This method is called by {@link #measureVertical(int, int)} and |
| * {@link #measureHorizontal(int, int)}.</p> |
| * |
| * @param child the child to measure |
| * @param childIndex the index of the child in this view |
| * @param widthMeasureSpec horizontal space requirements as imposed by the parent |
| * @param totalWidth extra space that has been used up by the parent horizontally |
| * @param heightMeasureSpec vertical space requirements as imposed by the parent |
| * @param totalHeight extra space that has been used up by the parent vertically |
| */ |
| void measureChildBeforeLayout(View child, int childIndex, |
| int widthMeasureSpec, int totalWidth, int heightMeasureSpec, |
| int totalHeight) { |
| measureChildWithMargins(child, widthMeasureSpec, totalWidth, |
| heightMeasureSpec, totalHeight); |
| } |
| |
| /** |
| * <p>Return the location offset of the specified child. This can be used |
| * by subclasses to change the location of a given widget.</p> |
| * |
| * @param child the child for which to obtain the location offset |
| * @return the location offset in pixels |
| */ |
| int getLocationOffset(View child) { |
| return 0; |
| } |
| |
| /** |
| * <p>Return the size offset of the next sibling of the specified child. |
| * This can be used by subclasses to change the location of the widget |
| * following <code>child</code>.</p> |
| * |
| * @param child the child whose next sibling will be moved |
| * @return the location offset of the next child in pixels |
| */ |
| int getNextLocationOffset(View child) { |
| return 0; |
| } |
| |
| @Override |
| protected void onLayout(boolean changed, int l, int t, int r, int b) { |
| if (mOrientation == VERTICAL) { |
| layoutVertical(l, t, r, b); |
| } else { |
| layoutHorizontal(l, t, r, b); |
| } |
| } |
| |
| /** |
| * Position the children during a layout pass if the orientation of this |
| * LinearLayout is set to {@link #VERTICAL}. |
| * |
| * @see #getOrientation() |
| * @see #setOrientation(int) |
| * @see #onLayout(boolean, int, int, int, int) |
| * @param left |
| * @param top |
| * @param right |
| * @param bottom |
| */ |
| void layoutVertical(int left, int top, int right, int bottom) { |
| final int paddingLeft = getPaddingLeft(); |
| |
| int childTop; |
| int childLeft; |
| |
| // Where right end of child should go |
| final int width = right - left; |
| int childRight = width - getPaddingRight(); |
| |
| // Space available for child |
| int childSpace = width - paddingLeft - getPaddingRight(); |
| |
| final int count = getVirtualChildCount(); |
| |
| final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK; |
| final int minorGravity = mGravity & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK; |
| |
| switch (majorGravity) { |
| case Gravity.BOTTOM: |
| // mTotalLength contains the padding already |
| childTop = getPaddingTop() + bottom - top - mTotalLength; |
| break; |
| |
| // mTotalLength contains the padding already |
| case Gravity.CENTER_VERTICAL: |
| childTop = getPaddingTop() + (bottom - top - mTotalLength) / 2; |
| break; |
| |
| case Gravity.TOP: |
| default: |
| childTop = getPaddingTop(); |
| break; |
| } |
| |
| for (int i = 0; i < count; i++) { |
| final View child = getVirtualChildAt(i); |
| if (child == null) { |
| childTop += measureNullChild(i); |
| } else if (child.getVisibility() != GONE) { |
| final int childWidth = child.getMeasuredWidth(); |
| final int childHeight = child.getMeasuredHeight(); |
| |
| final LinearLayoutCompat.LayoutParams lp = |
| (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| int gravity = lp.gravity; |
| if (gravity < 0) { |
| gravity = minorGravity; |
| } |
| final int layoutDirection = ViewCompat.getLayoutDirection(this); |
| final int absoluteGravity = GravityCompat.getAbsoluteGravity(gravity, |
| layoutDirection); |
| switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) { |
| case Gravity.CENTER_HORIZONTAL: |
| childLeft = paddingLeft + ((childSpace - childWidth) / 2) |
| + lp.leftMargin - lp.rightMargin; |
| break; |
| |
| case Gravity.RIGHT: |
| childLeft = childRight - childWidth - lp.rightMargin; |
| break; |
| |
| case Gravity.LEFT: |
| default: |
| childLeft = paddingLeft + lp.leftMargin; |
| break; |
| } |
| |
| if (hasDividerBeforeChildAt(i)) { |
| childTop += mDividerHeight; |
| } |
| |
| childTop += lp.topMargin; |
| setChildFrame(child, childLeft, childTop + getLocationOffset(child), |
| childWidth, childHeight); |
| childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child); |
| |
| i += getChildrenSkipCount(child, i); |
| } |
| } |
| } |
| |
| /** |
| * Position the children during a layout pass if the orientation of this |
| * LinearLayout is set to {@link #HORIZONTAL}. |
| * |
| * @see #getOrientation() |
| * @see #setOrientation(int) |
| * @see #onLayout(boolean, int, int, int, int) |
| * @param left |
| * @param top |
| * @param right |
| * @param bottom |
| */ |
| void layoutHorizontal(int left, int top, int right, int bottom) { |
| final boolean isLayoutRtl = ViewUtils.isLayoutRtl(this); |
| final int paddingTop = getPaddingTop(); |
| |
| int childTop; |
| int childLeft; |
| |
| // Where bottom of child should go |
| final int height = bottom - top; |
| int childBottom = height - getPaddingBottom(); |
| |
| // Space available for child |
| int childSpace = height - paddingTop - getPaddingBottom(); |
| |
| final int count = getVirtualChildCount(); |
| |
| final int majorGravity = mGravity & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK; |
| final int minorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK; |
| |
| final boolean baselineAligned = mBaselineAligned; |
| |
| final int[] maxAscent = mMaxAscent; |
| final int[] maxDescent = mMaxDescent; |
| |
| final int layoutDirection = ViewCompat.getLayoutDirection(this); |
| switch (GravityCompat.getAbsoluteGravity(majorGravity, layoutDirection)) { |
| case Gravity.RIGHT: |
| // mTotalLength contains the padding already |
| childLeft = getPaddingLeft() + right - left - mTotalLength; |
| break; |
| |
| case Gravity.CENTER_HORIZONTAL: |
| // mTotalLength contains the padding already |
| childLeft = getPaddingLeft() + (right - left - mTotalLength) / 2; |
| break; |
| |
| case Gravity.LEFT: |
| default: |
| childLeft = getPaddingLeft(); |
| break; |
| } |
| |
| int start = 0; |
| int dir = 1; |
| //In case of RTL, start drawing from the last child. |
| if (isLayoutRtl) { |
| start = count - 1; |
| dir = -1; |
| } |
| |
| for (int i = 0; i < count; i++) { |
| int childIndex = start + dir * i; |
| final View child = getVirtualChildAt(childIndex); |
| |
| if (child == null) { |
| childLeft += measureNullChild(childIndex); |
| } else if (child.getVisibility() != GONE) { |
| final int childWidth = child.getMeasuredWidth(); |
| final int childHeight = child.getMeasuredHeight(); |
| int childBaseline = -1; |
| |
| final LinearLayoutCompat.LayoutParams lp = |
| (LinearLayoutCompat.LayoutParams) child.getLayoutParams(); |
| |
| if (baselineAligned && lp.height != LayoutParams.MATCH_PARENT) { |
| childBaseline = child.getBaseline(); |
| } |
| |
| int gravity = lp.gravity; |
| if (gravity < 0) { |
| gravity = minorGravity; |
| } |
| |
| switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) { |
| case Gravity.TOP: |
| childTop = paddingTop + lp.topMargin; |
| if (childBaseline != -1) { |
| childTop += maxAscent[INDEX_TOP] - childBaseline; |
| } |
| break; |
| |
| case Gravity.CENTER_VERTICAL: |
| // Removed support for baseline alignment when layout_gravity or |
| // gravity == center_vertical. See bug #1038483. |
| // Keep the code around if we need to re-enable this feature |
| // if (childBaseline != -1) { |
| // // Align baselines vertically only if the child is smaller than us |
| // if (childSpace - childHeight > 0) { |
| // childTop = paddingTop + (childSpace / 2) - childBaseline; |
| // } else { |
| // childTop = paddingTop + (childSpace - childHeight) / 2; |
| // } |
| // } else { |
| childTop = paddingTop + ((childSpace - childHeight) / 2) |
| + lp.topMargin - lp.bottomMargin; |
| break; |
| |
| case Gravity.BOTTOM: |
| childTop = childBottom - childHeight - lp.bottomMargin; |
| if (childBaseline != -1) { |
| int descent = child.getMeasuredHeight() - childBaseline; |
| childTop -= (maxDescent[INDEX_BOTTOM] - descent); |
| } |
| break; |
| default: |
| childTop = paddingTop; |
| break; |
| } |
| |
| if (hasDividerBeforeChildAt(childIndex)) { |
| childLeft += mDividerWidth; |
| } |
| |
| childLeft += lp.leftMargin; |
| setChildFrame(child, childLeft + getLocationOffset(child), childTop, |
| childWidth, childHeight); |
| childLeft += childWidth + lp.rightMargin + |
| getNextLocationOffset(child); |
| |
| i += getChildrenSkipCount(child, childIndex); |
| } |
| } |
| } |
| |
| private void setChildFrame(View child, int left, int top, int width, int height) { |
| child.layout(left, top, left + width, top + height); |
| } |
| |
| /** |
| * Should the layout be a column or a row. |
| * @param orientation Pass {@link #HORIZONTAL} or {@link #VERTICAL}. Default |
| * value is {@link #HORIZONTAL}. |
| */ |
| public void setOrientation(@OrientationMode int orientation) { |
| if (mOrientation != orientation) { |
| mOrientation = orientation; |
| requestLayout(); |
| } |
| } |
| |
| /** |
| * Returns the current orientation. |
| * |
| * @return either {@link #HORIZONTAL} or {@link #VERTICAL} |
| */ |
| @OrientationMode |
| public int getOrientation() { |
| return mOrientation; |
| } |
| |
| /** |
| * Describes how the child views are positioned. Defaults to GRAVITY_TOP. If |
| * this layout has a VERTICAL orientation, this controls where all the child |
| * views are placed if there is extra vertical space. If this layout has a |
| * HORIZONTAL orientation, this controls the alignment of the children. |
| * |
| * @param gravity See {@link android.view.Gravity} |
| */ |
| public void setGravity(int gravity) { |
| if (mGravity != gravity) { |
| if ((gravity & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK) == 0) { |
| gravity |= GravityCompat.START; |
| } |
| |
| if ((gravity & Gravity.VERTICAL_GRAVITY_MASK) == 0) { |
| gravity |= Gravity.TOP; |
| } |
| |
| mGravity = gravity; |
| requestLayout(); |
| } |
| } |
| |
| /** |
| * Returns the current gravity. See {@link android.view.Gravity} |
| * |
| * @return the current gravity. |
| * @see #setGravity |
| */ |
| public int getGravity() { |
| return mGravity; |
| } |
| |
| public void setHorizontalGravity(int horizontalGravity) { |
| final int gravity = horizontalGravity & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK; |
| if ((mGravity & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK) != gravity) { |
| mGravity = (mGravity & ~GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK) | gravity; |
| requestLayout(); |
| } |
| } |
| |
| public void setVerticalGravity(int verticalGravity) { |
| final int gravity = verticalGravity & Gravity.VERTICAL_GRAVITY_MASK; |
| if ((mGravity & Gravity.VERTICAL_GRAVITY_MASK) != gravity) { |
| mGravity = (mGravity & ~Gravity.VERTICAL_GRAVITY_MASK) | gravity; |
| requestLayout(); |
| } |
| } |
| |
| @Override |
| public LayoutParams generateLayoutParams(AttributeSet attrs) { |
| return new LinearLayoutCompat.LayoutParams(getContext(), attrs); |
| } |
| |
| /** |
| * Returns a set of layout parameters with a width of |
| * {@link android.view.ViewGroup.LayoutParams#MATCH_PARENT} |
| * and a height of {@link android.view.ViewGroup.LayoutParams#WRAP_CONTENT} |
| * when the layout's orientation is {@link #VERTICAL}. When the orientation is |
| * {@link #HORIZONTAL}, the width is set to {@link LayoutParams#WRAP_CONTENT} |
| * and the height to {@link LayoutParams#WRAP_CONTENT}. |
| */ |
| @Override |
| protected LayoutParams generateDefaultLayoutParams() { |
| if (mOrientation == HORIZONTAL) { |
| return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT); |
| } else if (mOrientation == VERTICAL) { |
| return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT); |
| } |
| return null; |
| } |
| |
| @Override |
| protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) { |
| return new LayoutParams(p); |
| } |
| |
| |
| // Override to allow type-checking of LayoutParams. |
| @Override |
| protected boolean checkLayoutParams(ViewGroup.LayoutParams p) { |
| return p instanceof LinearLayoutCompat.LayoutParams; |
| } |
| |
| @Override |
| public void onInitializeAccessibilityEvent(AccessibilityEvent event) { |
| super.onInitializeAccessibilityEvent(event); |
| event.setClassName(ACCESSIBILITY_CLASS_NAME); |
| } |
| |
| @Override |
| public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo info) { |
| super.onInitializeAccessibilityNodeInfo(info); |
| info.setClassName(ACCESSIBILITY_CLASS_NAME); |
| } |
| |
| /** |
| * Per-child layout information associated with ViewLinearLayout. |
| */ |
| public static class LayoutParams extends LinearLayout.LayoutParams { |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public LayoutParams(Context c, AttributeSet attrs) { |
| super(c, attrs); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public LayoutParams(int width, int height) { |
| super(width, height); |
| } |
| |
| /** |
| * Creates a new set of layout parameters with the specified width, height |
| * and weight. |
| * |
| * @param width the width, either {@link #MATCH_PARENT}, |
| * {@link #WRAP_CONTENT} or a fixed size in pixels |
| * @param height the height, either {@link #MATCH_PARENT}, |
| * {@link #WRAP_CONTENT} or a fixed size in pixels |
| * @param weight the weight |
| */ |
| public LayoutParams(int width, int height, float weight) { |
| super(width, height, weight); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public LayoutParams(ViewGroup.LayoutParams p) { |
| super(p); |
| } |
| |
| /** |
| * {@inheritDoc} |
| */ |
| public LayoutParams(ViewGroup.MarginLayoutParams source) { |
| super(source); |
| } |
| } |
| } |
