mirror of
https://github.com/VibedByKaKi/alexandroid.git
synced 2026-11-14 01:47:17 +01:00
770 lines
30 KiB
Java
770 lines
30 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.InspectionCompanion;
|
|
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.biometric.ErrorUtils$$ExternalSyntheticOutline0;
|
|
import androidx.core.view.GravityCompat;
|
|
import androidx.core.view.ViewCompat;
|
|
import com.amazon.alexa.ra.core.ui.markdown.parser.formatter.MarkdownConstants;
|
|
import com.mapbox.maps.plugin.locationcomponent.ModelSourceWrapper;
|
|
import io.branch.referral.BranchError;
|
|
import io.ktor.http.CodecsKt$$ExternalSyntheticBUOutline0;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.HashSet;
|
|
import java.util.Set;
|
|
import java.util.function.IntFunction;
|
|
import rx.Single$$ExternalSyntheticBUOutline0;
|
|
|
|
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
|
|
/* 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;
|
|
|
|
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public @interface DividerMode {
|
|
}
|
|
|
|
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
|
|
@RequiresApi(29)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public final class InspectionCompanion implements android.view.inspector.InspectionCompanion<LinearLayoutCompat> {
|
|
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;
|
|
|
|
@Override // android.view.inspector.InspectionCompanion
|
|
public void mapProperties(@NonNull PropertyMapper propertyMapper) {
|
|
this.mBaselineAlignedId = propertyMapper.mapBoolean("baselineAligned", R.attr.baselineAligned);
|
|
this.mBaselineAlignedChildIndexId = propertyMapper.mapInt("baselineAlignedChildIndex", R.attr.baselineAlignedChildIndex);
|
|
this.mGravityId = propertyMapper.mapGravity("gravity", R.attr.gravity);
|
|
this.mOrientationId = propertyMapper.mapIntEnum(ModelSourceWrapper.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.mWeightSumId = propertyMapper.mapFloat("weightSum", R.attr.weightSum);
|
|
this.mDividerId = propertyMapper.mapObject("divider", androidx.appcompat.R.attr.divider);
|
|
this.mDividerPaddingId = propertyMapper.mapInt("dividerPadding", androidx.appcompat.R.attr.dividerPadding);
|
|
this.mMeasureWithLargestChildId = propertyMapper.mapBoolean("measureWithLargestChild", androidx.appcompat.R.attr.measureWithLargestChild);
|
|
this.mShowDividersId = 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("end");
|
|
}
|
|
return hashSet;
|
|
}
|
|
});
|
|
this.mPropertiesMapped = true;
|
|
}
|
|
|
|
@Override // android.view.inspector.InspectionCompanion
|
|
public void readProperties(@NonNull LinearLayoutCompat linearLayoutCompat, @NonNull PropertyReader propertyReader) {
|
|
if (!this.mPropertiesMapped) {
|
|
throw new InspectionCompanion.UninitializedPropertyMapException();
|
|
}
|
|
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());
|
|
}
|
|
}
|
|
|
|
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public @interface OrientationMode {
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
private void forceUniformHeight(int i, int i2) {
|
|
LinearLayoutCompat linearLayoutCompat;
|
|
int i3;
|
|
int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredHeight(), 1073741824);
|
|
int i4 = 0;
|
|
while (i4 < i) {
|
|
View virtualChildAt = this.getVirtualChildAt(i4);
|
|
if (virtualChildAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
|
|
if (((LinearLayout.LayoutParams) layoutParams).height == -1) {
|
|
int i5 = ((LinearLayout.LayoutParams) layoutParams).width;
|
|
((LinearLayout.LayoutParams) layoutParams).width = virtualChildAt.getMeasuredWidth();
|
|
linearLayoutCompat = this;
|
|
i3 = i2;
|
|
linearLayoutCompat.measureChildWithMargins(virtualChildAt, i3, 0, makeMeasureSpec, 0);
|
|
((LinearLayout.LayoutParams) layoutParams).width = i5;
|
|
i4++;
|
|
this = linearLayoutCompat;
|
|
i2 = i3;
|
|
}
|
|
}
|
|
linearLayoutCompat = this;
|
|
i3 = i2;
|
|
i4++;
|
|
this = linearLayoutCompat;
|
|
i2 = i3;
|
|
}
|
|
}
|
|
|
|
private void forceUniformWidth(int i, int i2) {
|
|
LinearLayoutCompat linearLayoutCompat;
|
|
int i3;
|
|
int makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(getMeasuredWidth(), 1073741824);
|
|
int i4 = 0;
|
|
while (i4 < i) {
|
|
View virtualChildAt = this.getVirtualChildAt(i4);
|
|
if (virtualChildAt.getVisibility() != 8) {
|
|
LayoutParams layoutParams = (LayoutParams) virtualChildAt.getLayoutParams();
|
|
if (((LinearLayout.LayoutParams) layoutParams).width == -1) {
|
|
int i5 = ((LinearLayout.LayoutParams) layoutParams).height;
|
|
((LinearLayout.LayoutParams) layoutParams).height = virtualChildAt.getMeasuredHeight();
|
|
linearLayoutCompat = this;
|
|
i3 = i2;
|
|
linearLayoutCompat.measureChildWithMargins(virtualChildAt, makeMeasureSpec, 0, i3, 0);
|
|
((LinearLayout.LayoutParams) layoutParams).height = i5;
|
|
i4++;
|
|
this = linearLayoutCompat;
|
|
i2 = i3;
|
|
}
|
|
}
|
|
linearLayoutCompat = this;
|
|
i3 = i2;
|
|
i4++;
|
|
this = linearLayoutCompat;
|
|
i2 = i3;
|
|
}
|
|
}
|
|
|
|
private void setChildFrame(View view, int i, int i2, int i3, int i4) {
|
|
view.layout(i, i2, i3 + i, i4 + i2);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean checkLayoutParams(ViewGroup.LayoutParams layoutParams) {
|
|
return layoutParams instanceof LayoutParams;
|
|
}
|
|
|
|
public void drawDividersHorizontal(Canvas canvas) {
|
|
int right;
|
|
int left;
|
|
int i;
|
|
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();
|
|
drawVerticalDivider(canvas, isLayoutRtl ? virtualChildAt.getRight() + ((LinearLayout.LayoutParams) layoutParams).rightMargin : (virtualChildAt.getLeft() - ((LinearLayout.LayoutParams) layoutParams).leftMargin) - this.mDividerWidth);
|
|
}
|
|
}
|
|
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 drawDividersVertical(Canvas canvas) {
|
|
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);
|
|
drawHorizontalDivider(canvas, virtualChildAt2 == null ? (getHeight() - getPaddingBottom()) - this.mDividerHeight : virtualChildAt2.getBottom() + ((LinearLayout.LayoutParams) ((LayoutParams) virtualChildAt2.getLayoutParams())).bottomMargin);
|
|
}
|
|
}
|
|
|
|
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.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) {
|
|
return layoutParams instanceof LayoutParams ? new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams) : layoutParams instanceof ViewGroup.MarginLayoutParams ? new LayoutParams((ViewGroup.MarginLayoutParams) layoutParams) : new LayoutParams(layoutParams);
|
|
}
|
|
|
|
@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) {
|
|
Single$$ExternalSyntheticBUOutline0.m("mBaselineAlignedChildIndex of LinearLayout set to an index that is out of bounds.");
|
|
return 0;
|
|
}
|
|
View childAt = getChildAt(i2);
|
|
int baseline = childAt.getBaseline();
|
|
if (baseline == -1) {
|
|
if (this.mBaselineAlignedChildIndex == 0) {
|
|
return -1;
|
|
}
|
|
Single$$ExternalSyntheticBUOutline0.m("mBaselineAlignedChildIndex of LinearLayout points to a View that doesn't know how to get its baseline.");
|
|
return 0;
|
|
}
|
|
int i3 = this.mBaselineChildTop;
|
|
if (this.mOrientation == 1 && (i = this.mGravity & 112) != 48) {
|
|
if (i == 16) {
|
|
i3 = ErrorUtils$$ExternalSyntheticOutline0.m(((getBottom() - getTop()) - getPaddingTop()) - getPaddingBottom(), this.mTotalLength, 2, i3);
|
|
} else if (i == 80) {
|
|
i3 = ((getBottom() - getTop()) - getPaddingBottom()) - this.mTotalLength;
|
|
}
|
|
}
|
|
return i3 + ((LinearLayout.LayoutParams) ((LayoutParams) childAt.getLayoutParams())).topMargin + baseline;
|
|
}
|
|
|
|
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 View getVirtualChildAt(int i) {
|
|
return getChildAt(i);
|
|
}
|
|
|
|
public int getVirtualChildCount() {
|
|
return getChildCount();
|
|
}
|
|
|
|
public float getWeightSum() {
|
|
return this.mWeightSum;
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY})
|
|
public boolean hasDividerBeforeChildAt(int i) {
|
|
if (i == 0) {
|
|
return (this.mShowDividers & 1) != 0;
|
|
}
|
|
int childCount = getChildCount();
|
|
int i2 = this.mShowDividers;
|
|
if (i == childCount) {
|
|
return (i2 & 4) != 0;
|
|
}
|
|
if ((i2 & 2) != 0) {
|
|
for (int i3 = i - 1; i3 >= 0; i3--) {
|
|
if (getChildAt(i3).getVisibility() != 8) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean isBaselineAligned() {
|
|
return this.mBaselineAligned;
|
|
}
|
|
|
|
public boolean isMeasureWithLargestChildEnabled() {
|
|
return this.mUseLargestChild;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:25:0x00b8 */
|
|
/* JADX WARN: Removed duplicated region for block: B:28:0x00c1 */
|
|
/* JADX WARN: Removed duplicated region for block: B:35:0x0100 */
|
|
/* JADX WARN: Removed duplicated region for block: B:38:0x0105 */
|
|
/* JADX WARN: Removed duplicated region for block: B:46:0x00ed */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void layoutHorizontal(int r22, int r23, int r24, int r25) {
|
|
/*
|
|
Method dump skipped, instructions count: 325
|
|
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");
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:25:0x009f */
|
|
/*
|
|
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;
|
|
r0 = r17
|
|
int r6 = r0.getPaddingLeft()
|
|
int r1 = r20 - r18
|
|
int r2 = r0.getPaddingRight()
|
|
int r7 = r1 - r2
|
|
int r1 = r1 - r6
|
|
int r2 = r0.getPaddingRight()
|
|
int r8 = r1 - r2
|
|
int r9 = r0.getVirtualChildCount()
|
|
int r1 = r0.mGravity
|
|
r2 = r1 & 112(0x70, float:1.57E-43)
|
|
r3 = 8388615(0x800007, float:1.1754953E-38)
|
|
r10 = r1 & r3
|
|
r1 = 16
|
|
r11 = 2
|
|
if (r2 == r1) goto L3c
|
|
r1 = 80
|
|
if (r2 == r1) goto L30
|
|
int r1 = r0.getPaddingTop()
|
|
goto L48
|
|
L30:
|
|
int r1 = r0.getPaddingTop()
|
|
int r1 = r1 + r21
|
|
int r1 = r1 - r19
|
|
int r2 = r0.mTotalLength
|
|
int r1 = r1 - r2
|
|
goto L48
|
|
L3c:
|
|
int r1 = r0.getPaddingTop()
|
|
int r2 = r21 - r19
|
|
int r3 = r0.mTotalLength
|
|
int r1 = androidx.biometric.ErrorUtils$$ExternalSyntheticOutline0.m(r2, r3, r11, r1)
|
|
L48:
|
|
r2 = 0
|
|
r12 = r2
|
|
L4a:
|
|
if (r12 >= r9) goto Lc3
|
|
r2 = r1
|
|
android.view.View r1 = r0.getVirtualChildAt(r12)
|
|
r13 = 1
|
|
if (r1 != 0) goto L5a
|
|
int r1 = r0.measureNullChild(r12)
|
|
int r1 = r1 + r2
|
|
goto Lc1
|
|
L5a:
|
|
int r3 = r1.getVisibility()
|
|
r4 = 8
|
|
if (r3 == r4) goto Lc0
|
|
int r4 = r1.getMeasuredWidth()
|
|
int r5 = r1.getMeasuredHeight()
|
|
android.view.ViewGroup$LayoutParams r3 = r1.getLayoutParams()
|
|
r14 = r3
|
|
androidx.appcompat.widget.LinearLayoutCompat$LayoutParams r14 = (androidx.appcompat.widget.LinearLayoutCompat.LayoutParams) r14
|
|
int r3 = r14.gravity
|
|
if (r3 >= 0) goto L76
|
|
r3 = r10
|
|
L76:
|
|
int r15 = r0.getLayoutDirection()
|
|
int r3 = androidx.core.view.GravityCompat.getAbsoluteGravity(r3, r15)
|
|
r3 = r3 & 7
|
|
if (r3 == r13) goto L8f
|
|
r15 = 5
|
|
if (r3 == r15) goto L89
|
|
int r3 = r14.leftMargin
|
|
int r3 = r3 + r6
|
|
goto L99
|
|
L89:
|
|
int r3 = r7 - r4
|
|
int r15 = r14.rightMargin
|
|
L8d:
|
|
int r3 = r3 - r15
|
|
goto L99
|
|
L8f:
|
|
int r3 = androidx.biometric.ErrorUtils$$ExternalSyntheticOutline0.m(r8, r4, r11, r6)
|
|
int r15 = r14.leftMargin
|
|
int r3 = r3 + r15
|
|
int r15 = r14.rightMargin
|
|
goto L8d
|
|
L99:
|
|
boolean r15 = r0.hasDividerBeforeChildAt(r12)
|
|
if (r15 == 0) goto La2
|
|
int r15 = r0.mDividerHeight
|
|
int r2 = r2 + r15
|
|
La2:
|
|
int r15 = r14.topMargin
|
|
int r15 = r15 + r2
|
|
int r2 = r0.getLocationOffset(r1)
|
|
int r2 = r2 + r15
|
|
r16 = r3
|
|
r3 = r2
|
|
r2 = r16
|
|
r0.setChildFrame(r1, r2, r3, r4, r5)
|
|
int r2 = r14.bottomMargin
|
|
int r5 = r5 + r2
|
|
int r2 = r0.getNextLocationOffset(r1)
|
|
int r2 = r2 + r5
|
|
int r2 = r2 + r15
|
|
int r1 = r0.getChildrenSkipCount(r1, r12)
|
|
int r12 = r12 + r1
|
|
Lc0:
|
|
r1 = r2
|
|
Lc1:
|
|
int r12 = r12 + r13
|
|
goto L4a
|
|
Lc3:
|
|
return
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.layoutVertical(int, int, int, int):void");
|
|
}
|
|
|
|
public void measureChildBeforeLayout(View view, int i, int i2, int i3, int i4, int i5) {
|
|
measureChildWithMargins(view, i2, i3, i4, i5);
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:182:0x0453 */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void measureHorizontal(int r39, int r40) {
|
|
/*
|
|
Method dump skipped, instructions count: 1273
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureHorizontal(int, int):void");
|
|
}
|
|
|
|
public int measureNullChild(int i) {
|
|
return 0;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:46:0x0154 */
|
|
/* JADX WARN: Removed duplicated region for block: B:51:0x015e */
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void measureVertical(int r28, int r29) {
|
|
/*
|
|
Method dump skipped, instructions count: 879
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.appcompat.widget.LinearLayoutCompat.measureVertical(int, int):void");
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onDraw(@NonNull Canvas canvas) {
|
|
if (this.mDivider == null) {
|
|
return;
|
|
}
|
|
if (this.mOrientation == 1) {
|
|
drawDividersVertical(canvas);
|
|
} else {
|
|
drawDividersHorizontal(canvas);
|
|
}
|
|
}
|
|
|
|
@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);
|
|
}
|
|
|
|
@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);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void onMeasure(int i, int i2) {
|
|
if (this.mOrientation == 1) {
|
|
measureVertical(i, i2);
|
|
} else {
|
|
measureHorizontal(i, i2);
|
|
}
|
|
}
|
|
|
|
public void setBaselineAligned(boolean z) {
|
|
this.mBaselineAligned = z;
|
|
}
|
|
|
|
public void setBaselineAlignedChildIndex(int i) {
|
|
if (i < 0 || i >= getChildCount()) {
|
|
CodecsKt$$ExternalSyntheticBUOutline0.m(getChildCount(), "base aligned child index out of range (0, ", MarkdownConstants.RIGHT_PARENTHESIS);
|
|
} else {
|
|
this.mBaselineAlignedChildIndex = 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();
|
|
}
|
|
|
|
public void setDividerPadding(int i) {
|
|
this.mDividerPadding = i;
|
|
}
|
|
|
|
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 setMeasureWithLargestChildEnabled(boolean z) {
|
|
this.mUseLargestChild = z;
|
|
}
|
|
|
|
public void setOrientation(int i) {
|
|
if (this.mOrientation != i) {
|
|
this.mOrientation = i;
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setShowDividers(int i) {
|
|
if (i != this.mShowDividers) {
|
|
requestLayout();
|
|
}
|
|
this.mShowDividers = i;
|
|
}
|
|
|
|
public void setVerticalGravity(int i) {
|
|
int i2 = i & 112;
|
|
int i3 = this.mGravity;
|
|
if ((i3 & 112) != i2) {
|
|
this.mGravity = i2 | (i3 & BranchError.ERR_BRANCH_NO_CONNECTIVITY);
|
|
requestLayout();
|
|
}
|
|
}
|
|
|
|
public void setWeightSum(float f) {
|
|
this.mWeightSum = Math.max(0.0f, f);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean shouldDelayChildPressedState() {
|
|
return false;
|
|
}
|
|
|
|
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
|
|
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);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(AttributeSet attributeSet) {
|
|
return new LayoutParams(getContext(), attributeSet);
|
|
}
|
|
|
|
public LinearLayoutCompat(@NonNull Context context, @Nullable AttributeSet attributeSet) {
|
|
this(context, attributeSet, 0);
|
|
}
|
|
|
|
public LinearLayoutCompat(@NonNull Context context) {
|
|
this(context, null);
|
|
}
|
|
}
|