Daniel Elliott
c080f0d97f
- Added realracing3-community.apk (71.57 MB) - Removed 32-bit support (armeabi-v7a) - Only includes arm64-v8a libraries - Decompiled source code included - Added README-community.md with analysis
776 lines
29 KiB
Java
776 lines
29 KiB
Java
package androidx.appcompat.widget;
|
|
|
|
import android.R;
|
|
import android.content.Context;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.util.AttributeSet;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.accessibility.AccessibilityEvent;
|
|
import android.view.accessibility.AccessibilityNodeInfo;
|
|
import android.view.inspector.PropertyMapper;
|
|
import android.view.inspector.PropertyReader;
|
|
import android.widget.LinearLayout;
|
|
import androidx.annotation.GravityInt;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RequiresApi;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.core.view.GravityCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import java.util.function.IntFunction;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class LinearLayoutCompat extends ViewGroup {
|
|
private static final String ACCESSIBILITY_CLASS_NAME = "androidx.appcompat.widget.LinearLayoutCompat";
|
|
public static final int HORIZONTAL = 0;
|
|
private static final int INDEX_BOTTOM = 2;
|
|
private static final int INDEX_CENTER_VERTICAL = 0;
|
|
private static final int INDEX_FILL = 3;
|
|
private static final int INDEX_TOP = 1;
|
|
public static final int SHOW_DIVIDER_BEGINNING = 1;
|
|
public static final int SHOW_DIVIDER_END = 4;
|
|
public static final int SHOW_DIVIDER_MIDDLE = 2;
|
|
public static final int SHOW_DIVIDER_NONE = 0;
|
|
public static final int VERTICAL = 1;
|
|
private static final int VERTICAL_GRAVITY_COUNT = 4;
|
|
private boolean mBaselineAligned;
|
|
private int mBaselineAlignedChildIndex;
|
|
private int mBaselineChildTop;
|
|
private Drawable mDivider;
|
|
private int mDividerHeight;
|
|
private int mDividerPadding;
|
|
private int mDividerWidth;
|
|
private int mGravity;
|
|
private int[] mMaxAscent;
|
|
private int[] mMaxDescent;
|
|
private int mOrientation;
|
|
private int mShowDividers;
|
|
private int mTotalLength;
|
|
private boolean mUseLargestChild;
|
|
private float mWeightSum;
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public @interface DividerMode {
|
|
}
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public @interface OrientationMode {
|
|
}
|
|
|
|
public int getBaselineAlignedChildIndex() {
|
|
return this.mBaselineAlignedChildIndex;
|
|
}
|
|
|
|
public int getChildrenSkipCount(View view, int i) {
|
|
return 0;
|
|
}
|
|
|
|
public Drawable getDividerDrawable() {
|
|
return this.mDivider;
|
|
}
|
|
|
|
public int getDividerPadding() {
|
|
return this.mDividerPadding;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public int getDividerWidth() {
|
|
return this.mDividerWidth;
|
|
}
|
|
|
|
@GravityInt
|
|
public int getGravity() {
|
|
return this.mGravity;
|
|
}
|
|
|
|
public int getLocationOffset(View view) {
|
|
return 0;
|
|
}
|
|
|
|
public int getNextLocationOffset(View view) {
|
|
return 0;
|
|
}
|
|
|
|
public int getOrientation() {
|
|
return this.mOrientation;
|
|
}
|
|
|
|
public int getShowDividers() {
|
|
return this.mShowDividers;
|
|
}
|
|
|
|
public float getWeightSum() {
|
|
return this.mWeightSum;
|
|
}
|
|
|
|
public boolean isBaselineAligned() {
|
|
return this.mBaselineAligned;
|
|
}
|
|
|
|
public boolean isMeasureWithLargestChildEnabled() {
|
|
return this.mUseLargestChild;
|
|
}
|
|
|
|
public int measureNullChild(int i) {
|
|
return 0;
|
|
}
|
|
|
|
public void setBaselineAligned(boolean z) {
|
|
this.mBaselineAligned = z;
|
|
}
|
|
|
|
public void setDividerPadding(int i) {
|
|
this.mDividerPadding = i;
|
|
}
|
|
|
|
public void setMeasureWithLargestChildEnabled(boolean z) {
|
|
this.mUseLargestChild = z;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean shouldDelayChildPressedState() {
|
|
return false;
|
|
}
|
|
|
|
@RequiresApi(29)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public final class InspectionCompanion implements android.view.inspector.InspectionCompanion {
|
|
private int mBaselineAlignedChildIndexId;
|
|
private int mBaselineAlignedId;
|
|
private int mDividerId;
|
|
private int mDividerPaddingId;
|
|
private int mGravityId;
|
|
private int mMeasureWithLargestChildId;
|
|
private int mOrientationId;
|
|
private boolean mPropertiesMapped = false;
|
|
private int mShowDividersId;
|
|
private int mWeightSumId;
|
|
|
|
public void mapProperties(@NonNull PropertyMapper propertyMapper) {
|
|
int mapBoolean;
|
|
int mapInt;
|
|
int mapGravity;
|
|
int mapIntEnum;
|
|
int mapFloat;
|
|
int mapObject;
|
|
int mapInt2;
|
|
int mapBoolean2;
|
|
int mapIntFlag;
|
|
mapBoolean = propertyMapper.mapBoolean("baselineAligned", R.attr.baselineAligned);
|
|
this.mBaselineAlignedId = mapBoolean;
|
|
mapInt = propertyMapper.mapInt("baselineAlignedChildIndex", R.attr.baselineAlignedChildIndex);
|
|
this.mBaselineAlignedChildIndexId = mapInt;
|
|
mapGravity = propertyMapper.mapGravity("gravity", R.attr.gravity);
|
|
this.mGravityId = mapGravity;
|
|
mapIntEnum = propertyMapper.mapIntEnum("orientation", R.attr.orientation, new IntFunction<String>() { // from class: androidx.appcompat.widget.LinearLayoutCompat.InspectionCompanion.1
|
|
@Override // java.util.function.IntFunction
|
|
public String apply(int i) {
|
|
return i != 0 ? i != 1 ? String.valueOf(i) : "vertical" : "horizontal";
|
|
}
|
|
});
|
|
this.mOrientationId = mapIntEnum;
|
|
mapFloat = propertyMapper.mapFloat("weightSum", R.attr.weightSum);
|
|
this.mWeightSumId = mapFloat;
|
|
mapObject = propertyMapper.mapObject("divider", androidx.appcompat.R.attr.divider);
|
|
this.mDividerId = mapObject;
|
|
mapInt2 = propertyMapper.mapInt("dividerPadding", androidx.appcompat.R.attr.dividerPadding);
|
|
this.mDividerPaddingId = mapInt2;
|
|
mapBoolean2 = propertyMapper.mapBoolean("measureWithLargestChild", androidx.appcompat.R.attr.measureWithLargestChild);
|
|
this.mMeasureWithLargestChildId = mapBoolean2;
|
|
mapIntFlag = propertyMapper.mapIntFlag("showDividers", androidx.appcompat.R.attr.showDividers, new IntFunction<Set<String>>() { // from class: androidx.appcompat.widget.LinearLayoutCompat.InspectionCompanion.2
|
|
@Override // java.util.function.IntFunction
|
|
public Set<String> apply(int i) {
|
|
HashSet hashSet = new HashSet();
|
|
if (i == 0) {
|
|
hashSet.add("none");
|
|
}
|
|
if (i == 1) {
|
|
hashSet.add("beginning");
|
|
}
|
|
if (i == 2) {
|
|
hashSet.add("middle");
|
|
}
|
|
if (i == 4) {
|
|
hashSet.add(TtmlNode.END);
|
|
}
|
|
return hashSet;
|
|
}
|
|
});
|
|
this.mShowDividersId = mapIntFlag;
|
|
this.mPropertiesMapped = true;
|
|
}
|
|
|
|
public void readProperties(@NonNull LinearLayoutCompat linearLayoutCompat, @NonNull PropertyReader propertyReader) {
|
|
if (!this.mPropertiesMapped) {
|
|
throw AppCompatAutoCompleteTextView$InspectionCompanion$$ExternalSyntheticApiModelOutline2.m();
|
|
}
|
|
propertyReader.readBoolean(this.mBaselineAlignedId, linearLayoutCompat.isBaselineAligned());
|
|
propertyReader.readInt(this.mBaselineAlignedChildIndexId, linearLayoutCompat.getBaselineAlignedChildIndex());
|
|
propertyReader.readGravity(this.mGravityId, linearLayoutCompat.getGravity());
|
|
propertyReader.readIntEnum(this.mOrientationId, linearLayoutCompat.getOrientation());
|
|
propertyReader.readFloat(this.mWeightSumId, linearLayoutCompat.getWeightSum());
|
|
propertyReader.readObject(this.mDividerId, linearLayoutCompat.getDividerDrawable());
|
|
propertyReader.readInt(this.mDividerPaddingId, linearLayoutCompat.getDividerPadding());
|
|
propertyReader.readBoolean(this.mMeasureWithLargestChildId, linearLayoutCompat.isMeasureWithLargestChildEnabled());
|
|
propertyReader.readIntFlag(this.mShowDividersId, linearLayoutCompat.getShowDividers());
|
|
}
|
|
}
|
|
|
|
public LinearLayoutCompat(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
|
|
public LinearLayoutCompat(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
this(context, attributeSet, 0);
|
|
}
|
|
|
|
public LinearLayoutCompat(@NonNull Context context, @Nullable AttributeSet attributeSet, int i) {
|
|
super(context, attributeSet, i);
|
|
this.mBaselineAligned = true;
|
|
this.mBaselineAlignedChildIndex = -1;
|
|
this.mBaselineChildTop = 0;
|
|
this.mGravity = 8388659;
|
|
TintTypedArray obtainStyledAttributes = TintTypedArray.obtainStyledAttributes(context, attributeSet, androidx.appcompat.R.styleable.LinearLayoutCompat, i, 0);
|
|
ViewCompat.saveAttributeDataForStyleable(this, context, androidx.appcompat.R.styleable.LinearLayoutCompat, attributeSet, obtainStyledAttributes.getWrappedTypeArray(), i, 0);
|
|
int i2 = obtainStyledAttributes.getInt(androidx.appcompat.R.styleable.LinearLayoutCompat_android_orientation, -1);
|
|
if (i2 >= 0) {
|
|
setOrientation(i2);
|
|
}
|
|
int i3 = obtainStyledAttributes.getInt(androidx.appcompat.R.styleable.LinearLayoutCompat_android_gravity, -1);
|
|
if (i3 >= 0) {
|
|
setGravity(i3);
|
|
}
|
|
boolean z = obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.LinearLayoutCompat_android_baselineAligned, true);
|
|
if (!z) {
|
|
setBaselineAligned(z);
|
|
}
|
|
this.mWeightSum = obtainStyledAttributes.getFloat(androidx.appcompat.R.styleable.LinearLayoutCompat_android_weightSum, -1.0f);
|
|
this.mBaselineAlignedChildIndex = obtainStyledAttributes.getInt(androidx.appcompat.R.styleable.LinearLayoutCompat_android_baselineAlignedChildIndex, -1);
|
|
this.mUseLargestChild = obtainStyledAttributes.getBoolean(androidx.appcompat.R.styleable.LinearLayoutCompat_measureWithLargestChild, false);
|
|
setDividerDrawable(obtainStyledAttributes.getDrawable(androidx.appcompat.R.styleable.LinearLayoutCompat_divider));
|
|
this.mShowDividers = obtainStyledAttributes.getInt(androidx.appcompat.R.styleable.LinearLayoutCompat_showDividers, 0);
|
|
this.mDividerPadding = obtainStyledAttributes.getDimensionPixelSize(androidx.appcompat.R.styleable.LinearLayoutCompat_dividerPadding, 0);
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
|
|
public void setShowDividers(int i) {
|
|
if (i != this.mShowDividers) {
|
|
requestLayout();
|
|
}
|
|
this.mShowDividers = i;
|
|
}
|
|
|
|
public void setDividerDrawable(Drawable drawable) {
|
|
if (drawable == this.mDivider) {
|
|
return;
|
|
}
|
|
this.mDivider = drawable;
|
|
if (drawable != null) {
|
|
this.mDividerWidth = drawable.getIntrinsicWidth();
|
|
this.mDividerHeight = drawable.getIntrinsicHeight();
|
|
} else {
|
|
this.mDividerWidth = 0;
|
|
this.mDividerHeight = 0;
|
|
}
|
|
setWillNotDraw(drawable == null);
|
|
requestLayout();
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onDraw(@NonNull Canvas canvas) {
|
|
if (this.mDivider == null) {
|
|
return;
|
|
}
|
|
if (this.mOrientation == 1) {
|
|
drawDividersVertical(canvas);
|
|
} else {
|
|
drawDividersHorizontal(canvas);
|
|
}
|
|
}
|
|
|
|
public void drawDividersVertical(Canvas canvas) {
|
|
int bottom;
|
|
int virtualChildCount = getVirtualChildCount();
|
|
for (int i = 0; i < virtualChildCount; i++) {
|
|
View virtualChildAt = getVirtualChildAt(i);
|
|
if (virtualChildAt != null && virtualChildAt.getVisibility() != 8 && hasDividerBeforeChildAt(i)) {
|
|
drawHorizontalDivider(canvas, (virtualChildAt.getTop() - ((LinearLayout.LayoutParams) ((LayoutParams) virtualChildAt.getLayoutParams())).topMargin) - this.mDividerHeight);
|
|
}
|
|
}
|
|
if (hasDividerBeforeChildAt(virtualChildCount)) {
|
|
View virtualChildAt2 = getVirtualChildAt(virtualChildCount - 1);
|
|
if (virtualChildAt2 == null) {
|
|
bottom = (getHeight() - getPaddingBottom()) - this.mDividerHeight;
|
|
} else {
|
|
bottom = virtualChildAt2.getBottom() + ((LinearLayout.LayoutParams) ((LayoutParams) virtualChildAt2.getLayoutParams())).bottomMargin;
|
|
}
|
|
drawHorizontalDivider(canvas, bottom);
|
|
}
|
|
}
|
|
|
|
public void drawDividersHorizontal(Canvas canvas) {
|
|
int right;
|
|
int left;
|
|
int i;
|
|
int left2;
|
|
int virtualChildCount = getVirtualChildCount();
|
|
boolean isLayoutRtl = ViewUtils.isLayoutRtl(this);
|
|
for (int i2 = 0; i2 < virtualChildCount; i2++) {
|
|
View virtualChildAt = getVirtualChildAt(i2);
|
|
if (virtualChildAt != null && virtualChildAt.getVisibility() != 8 && hasDividerBeforeChildAt(i2)) {
|
|
LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
|
|
if (isLayoutRtl) {
|
|
left2 = virtualChildAt.getRight() + ((LinearLayout.LayoutParams) layoutParams).rightMargin;
|
|
} else {
|
|
left2 = (virtualChildAt.getLeft() - ((LinearLayout.LayoutParams) layoutParams).leftMargin) - this.mDividerWidth;
|
|
}
|
|
drawVerticalDivider(canvas, left2);
|
|
}
|
|
}
|
|
if (hasDividerBeforeChildAt(virtualChildCount)) {
|
|
View virtualChildAt2 = getVirtualChildAt(virtualChildCount - 1);
|
|
if (virtualChildAt2 != null) {
|
|
LayoutParams layoutParams2 = (LayoutParams) virtualChildAt2.getLayoutParams();
|
|
if (isLayoutRtl) {
|
|
left = virtualChildAt2.getLeft() - ((LinearLayout.LayoutParams) layoutParams2).leftMargin;
|
|
i = this.mDividerWidth;
|
|
right = left - i;
|
|
} else {
|
|
right = virtualChildAt2.getRight() + ((LinearLayout.LayoutParams) layoutParams2).rightMargin;
|
|
}
|
|
} else if (isLayoutRtl) {
|
|
right = getPaddingLeft();
|
|
} else {
|
|
left = getWidth() - getPaddingRight();
|
|
i = this.mDividerWidth;
|
|
right = left - i;
|
|
}
|
|
drawVerticalDivider(canvas, right);
|
|
}
|
|
}
|
|
|
|
public void drawHorizontalDivider(Canvas canvas, int i) {
|
|
this.mDivider.setBounds(getPaddingLeft() + this.mDividerPadding, i, (getWidth() - getPaddingRight()) - this.mDividerPadding, this.mDividerHeight + i);
|
|
this.mDivider.draw(canvas);
|
|
}
|
|
|
|
public void drawVerticalDivider(Canvas canvas, int i) {
|
|
this.mDivider.setBounds(i, getPaddingTop() + this.mDividerPadding, this.mDividerWidth + i, (getHeight() - getPaddingBottom()) - this.mDividerPadding);
|
|
this.mDivider.draw(canvas);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public int getBaseline() {
|
|
int i;
|
|
if (this.mBaselineAlignedChildIndex < 0) {
|
|
return super.getBaseline();
|
|
}
|
|
int childCount = getChildCount();
|
|
int i2 = this.mBaselineAlignedChildIndex;
|
|
if (childCount <= i2) {
|
|
throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout set to an index that is out of bounds.");
|
|
}
|
|
View childAt = getChildAt(i2);
|
|
int baseline = childAt.getBaseline();
|
|
if (baseline == -1) {
|
|
if (this.mBaselineAlignedChildIndex == 0) {
|
|
return -1;
|
|
}
|
|
throw new RuntimeException("mBaselineAlignedChildIndex of LinearLayout points to a View that doesn't know how to get its baseline.");
|
|
}
|
|
int i3 = this.mBaselineChildTop;
|
|
if (this.mOrientation == 1 && (i = this.mGravity & 112) != 48) {
|
|
if (i == 16) {
|
|
i3 += ((((getBottom() - getTop()) - getPaddingTop()) - getPaddingBottom()) - this.mTotalLength) / 2;
|
|
} else if (i == 80) {
|
|
i3 = ((getBottom() - getTop()) - getPaddingBottom()) - this.mTotalLength;
|
|
}
|
|
}
|
|
return i3 + ((LinearLayout.LayoutParams) ((LayoutParams) childAt.getLayoutParams())).topMargin + baseline;
|
|
}
|
|
|
|
public void setBaselineAlignedChildIndex(int i) {
|
|
if (i >= 0 && i < getChildCount()) {
|
|
this.mBaselineAlignedChildIndex = i;
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException("base aligned child index out of range (0, " + getChildCount() + ")");
|
|
}
|
|
|
|
public View getVirtualChildAt(int i) {
|
|
return getChildAt(i);
|
|
}
|
|
|
|
public int getVirtualChildCount() {
|
|
return getChildCount();
|
|
}
|
|
|
|
public void setWeightSum(float f) {
|
|
this.mWeightSum = Math.max(0.0f, f);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onMeasure(int i, int i2) {
|
|
if (this.mOrientation == 1) {
|
|
measureVertical(i, i2);
|
|
} else {
|
|
measureHorizontal(i, i2);
|
|
}
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public boolean hasDividerBeforeChildAt(int i) {
|
|
if (i == 0) {
|
|
return (this.mShowDividers & 1) != 0;
|
|
}
|
|
if (i == getChildCount()) {
|
|
return (this.mShowDividers & 4) != 0;
|
|
}
|
|
if ((this.mShowDividers & 2) == 0) {
|
|
return false;
|
|
}
|
|
for (int i2 = i - 1; i2 >= 0; i2--) {
|
|
if (getChildAt(i2).getVisibility() != 8) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX WARN: Code restructure failed: missing block: B:157:0x031c, code lost:
|
|
|
|
if (((android.widget.LinearLayout.LayoutParams) r14).width == (-1)) goto L148;
|
|
*/
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void measureVertical(int r34, int r35) {
|
|
/*
|
|
Method dump skipped, instructions count: 911
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureVertical(int, int):void");
|
|
}
|
|
|
|
private void forceUniformWidth(int i, int i2) {
|
|
int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredWidth(), 1073741824);
|
|
for (int i3 = 0; i3 < i; i3++) {
|
|
View virtualChildAt = getVirtualChildAt(i3);
|
|
if (virtualChildAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
|
|
if (((LinearLayout.LayoutParams) layoutParams).width == -1) {
|
|
int i4 = ((LinearLayout.LayoutParams) layoutParams).height;
|
|
((LinearLayout.LayoutParams) layoutParams).height = virtualChildAt.getMeasuredHeight();
|
|
measureChildWithMargins(virtualChildAt, makeMeasureSpec, 0, i2, 0);
|
|
((LinearLayout.LayoutParams) layoutParams).height = i4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:200:0x045b */
|
|
/* JADX WARN: Removed duplicated region for block: B:44:0x0197 */
|
|
/* JADX WARN: Removed duplicated region for block: B:53:0x01cb */
|
|
/* JADX WARN: Removed duplicated region for block: B:60:0x01d9 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void measureHorizontal(int r40, int r41) {
|
|
/*
|
|
Method dump skipped, instructions count: 1293
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureHorizontal(int, int):void");
|
|
}
|
|
|
|
private void forceUniformHeight(int i, int i2) {
|
|
int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredHeight(), 1073741824);
|
|
for (int i3 = 0; i3 < i; i3++) {
|
|
View virtualChildAt = getVirtualChildAt(i3);
|
|
if (virtualChildAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
|
|
if (((LinearLayout.LayoutParams) layoutParams).height == -1) {
|
|
int i4 = ((LinearLayout.LayoutParams) layoutParams).width;
|
|
((LinearLayout.LayoutParams) layoutParams).width = virtualChildAt.getMeasuredWidth();
|
|
measureChildWithMargins(virtualChildAt, i2, 0, makeMeasureSpec, 0);
|
|
((LinearLayout.LayoutParams) layoutParams).width = i4;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void measureChildBeforeLayout(View view, int i, int i2, int i3, int i4, int i5) {
|
|
measureChildWithMargins(view, i2, i3, i4, i5);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
public void onLayout(boolean z, int i, int i2, int i3, int i4) {
|
|
if (this.mOrientation == 1) {
|
|
layoutVertical(i, i2, i3, i4);
|
|
} else {
|
|
layoutHorizontal(i, i2, i3, i4);
|
|
}
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:27:0x00a1 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void layoutVertical(int r18, int r19, int r20, int r21) {
|
|
/*
|
|
r17 = this;
|
|
r6 = r17
|
|
int r7 = r17.getPaddingLeft()
|
|
int r0 = r20 - r18
|
|
int r1 = r17.getPaddingRight()
|
|
int r8 = r0 - r1
|
|
int r0 = r0 - r7
|
|
int r1 = r17.getPaddingRight()
|
|
int r9 = r0 - r1
|
|
int r10 = r17.getVirtualChildCount()
|
|
int r0 = r6.mGravity
|
|
r1 = r0 & 112(0x70, float:1.57E-43)
|
|
r2 = 8388615(0x800007, float:1.1754953E-38)
|
|
r11 = r0 & r2
|
|
r0 = 16
|
|
if (r1 == r0) goto L3b
|
|
r0 = 80
|
|
if (r1 == r0) goto L2f
|
|
int r0 = r17.getPaddingTop()
|
|
goto L47
|
|
L2f:
|
|
int r0 = r17.getPaddingTop()
|
|
int r0 = r0 + r21
|
|
int r0 = r0 - r19
|
|
int r1 = r6.mTotalLength
|
|
int r0 = r0 - r1
|
|
goto L47
|
|
L3b:
|
|
int r0 = r17.getPaddingTop()
|
|
int r1 = r21 - r19
|
|
int r2 = r6.mTotalLength
|
|
int r1 = r1 - r2
|
|
int r1 = r1 / 2
|
|
int r0 = r0 + r1
|
|
L47:
|
|
r1 = 0
|
|
r12 = r1
|
|
L49:
|
|
if (r12 >= r10) goto Lcb
|
|
android.view.View r13 = r6.getVirtualChildAt(r12)
|
|
r14 = 1
|
|
if (r13 != 0) goto L5a
|
|
int r1 = r6.measureNullChild(r12)
|
|
int r0 = r0 + r1
|
|
L57:
|
|
r1 = r14
|
|
goto Lc8
|
|
L5a:
|
|
int r1 = r13.getVisibility()
|
|
r2 = 8
|
|
if (r1 == r2) goto L57
|
|
int r4 = r13.getMeasuredWidth()
|
|
int r15 = r13.getMeasuredHeight()
|
|
android.view.ViewGroup$LayoutParams r1 = r13.getLayoutParams()
|
|
r5 = r1
|
|
androidx.appcompat.widget.LinearLayoutCompat$LayoutParams r5 = (androidx.appcompat.widget.LinearLayoutCompat.LayoutParams) r5
|
|
int r1 = r5.gravity
|
|
if (r1 >= 0) goto L76
|
|
r1 = r11
|
|
L76:
|
|
int r2 = r17.getLayoutDirection()
|
|
int r1 = androidx.core.view.GravityCompat.getAbsoluteGravity(r1, r2)
|
|
r1 = r1 & 7
|
|
if (r1 == r14) goto L90
|
|
r2 = 5
|
|
if (r1 == r2) goto L8a
|
|
int r1 = r5.leftMargin
|
|
int r1 = r1 + r7
|
|
L88:
|
|
r2 = r1
|
|
goto L9b
|
|
L8a:
|
|
int r1 = r8 - r4
|
|
int r2 = r5.rightMargin
|
|
L8e:
|
|
int r1 = r1 - r2
|
|
goto L88
|
|
L90:
|
|
int r1 = r9 - r4
|
|
int r1 = r1 / 2
|
|
int r1 = r1 + r7
|
|
int r2 = r5.leftMargin
|
|
int r1 = r1 + r2
|
|
int r2 = r5.rightMargin
|
|
goto L8e
|
|
L9b:
|
|
boolean r1 = r6.hasDividerBeforeChildAt(r12)
|
|
if (r1 == 0) goto La4
|
|
int r1 = r6.mDividerHeight
|
|
int r0 = r0 + r1
|
|
La4:
|
|
int r1 = r5.topMargin
|
|
int r16 = r0 + r1
|
|
int r0 = r6.getLocationOffset(r13)
|
|
int r3 = r16 + r0
|
|
r0 = r17
|
|
r1 = r13
|
|
r14 = r5
|
|
r5 = r15
|
|
r0.setChildFrame(r1, r2, r3, r4, r5)
|
|
int r0 = r14.bottomMargin
|
|
int r15 = r15 + r0
|
|
int r0 = r6.getNextLocationOffset(r13)
|
|
int r15 = r15 + r0
|
|
int r16 = r16 + r15
|
|
int r0 = r6.getChildrenSkipCount(r13, r12)
|
|
int r12 = r12 + r0
|
|
r0 = r16
|
|
r1 = 1
|
|
Lc8:
|
|
int r12 = r12 + r1
|
|
goto L49
|
|
Lcb:
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.layoutVertical(int, int, int, int):void");
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:26:0x00b1 */
|
|
/* JADX WARN: Removed duplicated region for block: B:29:0x00ba */
|
|
/* JADX WARN: Removed duplicated region for block: B:37:0x0100 */
|
|
/* JADX WARN: Removed duplicated region for block: B:46:0x00ec */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void layoutHorizontal(int r25, int r26, int r27, int r28) {
|
|
/*
|
|
Method dump skipped, instructions count: 331
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.layoutHorizontal(int, int, int, int):void");
|
|
}
|
|
|
|
private void setChildFrame(View view, int i, int i2, int i3, int i4) {
|
|
view.layout(i, i2, i3 + i, i4 + i2);
|
|
}
|
|
|
|
public void setOrientation(int i) {
|
|
if (this.mOrientation != i) {
|
|
this.mOrientation = i;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setGravity(@GravityInt int i) {
|
|
if (this.mGravity != i) {
|
|
if ((8388615 & i) == 0) {
|
|
i |= GravityCompat.START;
|
|
}
|
|
if ((i & 112) == 0) {
|
|
i |= 48;
|
|
}
|
|
this.mGravity = i;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setHorizontalGravity(int i) {
|
|
int i2 = i & GravityCompat.RELATIVE_HORIZONTAL_GRAVITY_MASK;
|
|
int i3 = this.mGravity;
|
|
if ((8388615 & i3) != i2) {
|
|
this.mGravity = i2 | ((-8388616) & i3);
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setVerticalGravity(int i) {
|
|
int i2 = i & 112;
|
|
int i3 = this.mGravity;
|
|
if ((i3 & 112) != i2) {
|
|
this.mGravity = i2 | (i3 & (-113));
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(AttributeSet attributeSet) {
|
|
return new LayoutParams(getContext(), attributeSet);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateDefaultLayoutParams() {
|
|
int i = this.mOrientation;
|
|
if (i == 0) {
|
|
return new LayoutParams(-2, -2);
|
|
}
|
|
if (i == 1) {
|
|
return new LayoutParams(-1, -2);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
if (layoutParams instanceof LayoutParams) {
|
|
return new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams);
|
|
}
|
|
if (layoutParams instanceof ViewGroup.MarginLayoutParams) {
|
|
return new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams);
|
|
}
|
|
return new LayoutParams(layoutParams);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
return layoutParams instanceof LayoutParams;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onInitializeAccessibilityEvent(AccessibilityEvent accessibilityEvent) {
|
|
super.onInitializeAccessibilityEvent(accessibilityEvent);
|
|
accessibilityEvent.setClassName(ACCESSIBILITY_CLASS_NAME);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo accessibilityNodeInfo) {
|
|
super.onInitializeAccessibilityNodeInfo(accessibilityNodeInfo);
|
|
accessibilityNodeInfo.setClassName(ACCESSIBILITY_CLASS_NAME);
|
|
}
|
|
|
|
public static class LayoutParams extends LinearLayout.LayoutParams {
|
|
public LayoutParams(Context context, AttributeSet attributeSet) {
|
|
super(context, attributeSet);
|
|
}
|
|
|
|
public LayoutParams(int i, int i2) {
|
|
super(i, i2);
|
|
}
|
|
|
|
public LayoutParams(int i, int i2, float f) {
|
|
super(i, i2, f);
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
super(layoutParams);
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.MarginLayoutParams marginLayoutParams) {
|
|
super(marginLayoutParams);
|
|
}
|
|
}
|
|
}
|