2230 lines
109 KiB
Java
2230 lines
109 KiB
Java
package androidx.constraintlayout.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.util.SparseIntArray;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import androidx.constraintlayout.core.Metrics;
|
|
import androidx.constraintlayout.core.widgets.ConstraintAnchor;
|
|
import androidx.constraintlayout.core.widgets.ConstraintWidget;
|
|
import androidx.constraintlayout.core.widgets.ConstraintWidgetContainer;
|
|
import androidx.constraintlayout.core.widgets.Optimizer;
|
|
import androidx.constraintlayout.core.widgets.analyzer.BasicMeasure;
|
|
import androidx.core.internal.view.SupportMenu;
|
|
import androidx.core.view.ViewCompat;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
|
|
/* loaded from: classes.dex */
|
|
public class ConstraintLayout extends ViewGroup {
|
|
private static final boolean DEBUG = false;
|
|
private static final boolean DEBUG_DRAW_CONSTRAINTS = false;
|
|
public static final int DESIGN_INFO_ID = 0;
|
|
private static final boolean MEASURE = false;
|
|
private static final boolean OPTIMIZE_HEIGHT_CHANGE = false;
|
|
private static final String TAG = "ConstraintLayout";
|
|
private static final boolean USE_CONSTRAINTS_HELPER = true;
|
|
public static final String VERSION = "ConstraintLayout-2.1.4";
|
|
private static SharedValues sSharedValues;
|
|
SparseArray<View> mChildrenByIds;
|
|
private ArrayList<ConstraintHelper> mConstraintHelpers;
|
|
protected ConstraintLayoutStates mConstraintLayoutSpec;
|
|
private ConstraintSet mConstraintSet;
|
|
private int mConstraintSetId;
|
|
private ConstraintsChangedListener mConstraintsChangedListener;
|
|
private HashMap<String, Integer> mDesignIds;
|
|
protected boolean mDirtyHierarchy;
|
|
private int mLastMeasureHeight;
|
|
int mLastMeasureHeightMode;
|
|
int mLastMeasureHeightSize;
|
|
private int mLastMeasureWidth;
|
|
int mLastMeasureWidthMode;
|
|
int mLastMeasureWidthSize;
|
|
protected ConstraintWidgetContainer mLayoutWidget;
|
|
private int mMaxHeight;
|
|
private int mMaxWidth;
|
|
Measurer mMeasurer;
|
|
private Metrics mMetrics;
|
|
private int mMinHeight;
|
|
private int mMinWidth;
|
|
private int mOnMeasureHeightMeasureSpec;
|
|
private int mOnMeasureWidthMeasureSpec;
|
|
private int mOptimizationLevel;
|
|
private SparseArray<ConstraintWidget> mTempMapIdToWidget;
|
|
|
|
private void markHierarchyDirty() {
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
this.mLastMeasureWidth = -1;
|
|
this.mLastMeasureHeight = -1;
|
|
this.mLastMeasureWidthSize = -1;
|
|
this.mLastMeasureHeightSize = -1;
|
|
this.mLastMeasureWidthMode = 0;
|
|
this.mLastMeasureHeightMode = 0;
|
|
}
|
|
|
|
public int getMaxHeight() {
|
|
return this.mMaxHeight;
|
|
}
|
|
|
|
public int getMaxWidth() {
|
|
return this.mMaxWidth;
|
|
}
|
|
|
|
public int getMinHeight() {
|
|
return this.mMinHeight;
|
|
}
|
|
|
|
public int getMinWidth() {
|
|
return this.mMinWidth;
|
|
}
|
|
|
|
public void setConstraintSet(ConstraintSet set) {
|
|
this.mConstraintSet = set;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public boolean shouldDelayChildPressedState() {
|
|
return false;
|
|
}
|
|
|
|
public static SharedValues getSharedValues() {
|
|
if (sSharedValues == null) {
|
|
sSharedValues = new SharedValues();
|
|
}
|
|
return sSharedValues;
|
|
}
|
|
|
|
public void setDesignInformation(int type, Object value1, Object value2) {
|
|
if (type == 0 && (value1 instanceof String) && (value2 instanceof Integer)) {
|
|
if (this.mDesignIds == null) {
|
|
this.mDesignIds = new HashMap<>();
|
|
}
|
|
String str = (String) value1;
|
|
int indexOf = str.indexOf("/");
|
|
if (indexOf != -1) {
|
|
str = str.substring(indexOf + 1);
|
|
}
|
|
this.mDesignIds.put(str, Integer.valueOf(((Integer) value2).intValue()));
|
|
}
|
|
}
|
|
|
|
public Object getDesignInformation(int type, Object value) {
|
|
if (type != 0 || !(value instanceof String)) {
|
|
return null;
|
|
}
|
|
String str = (String) value;
|
|
HashMap<String, Integer> hashMap = this.mDesignIds;
|
|
if (hashMap == null || !hashMap.containsKey(str)) {
|
|
return null;
|
|
}
|
|
return this.mDesignIds.get(str);
|
|
}
|
|
|
|
public ConstraintLayout(Context context) {
|
|
super(context);
|
|
this.mChildrenByIds = new SparseArray<>();
|
|
this.mConstraintHelpers = new ArrayList<>(4);
|
|
this.mLayoutWidget = new ConstraintWidgetContainer();
|
|
this.mMinWidth = 0;
|
|
this.mMinHeight = 0;
|
|
this.mMaxWidth = Integer.MAX_VALUE;
|
|
this.mMaxHeight = Integer.MAX_VALUE;
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
this.mOptimizationLevel = 257;
|
|
this.mConstraintSet = null;
|
|
this.mConstraintLayoutSpec = null;
|
|
this.mConstraintSetId = -1;
|
|
this.mDesignIds = new HashMap<>();
|
|
this.mLastMeasureWidth = -1;
|
|
this.mLastMeasureHeight = -1;
|
|
this.mLastMeasureWidthSize = -1;
|
|
this.mLastMeasureHeightSize = -1;
|
|
this.mLastMeasureWidthMode = 0;
|
|
this.mLastMeasureHeightMode = 0;
|
|
this.mTempMapIdToWidget = new SparseArray<>();
|
|
this.mMeasurer = new Measurer(this);
|
|
this.mOnMeasureWidthMeasureSpec = 0;
|
|
this.mOnMeasureHeightMeasureSpec = 0;
|
|
init(null, 0, 0);
|
|
}
|
|
|
|
public ConstraintLayout(Context context, AttributeSet attrs) {
|
|
super(context, attrs);
|
|
this.mChildrenByIds = new SparseArray<>();
|
|
this.mConstraintHelpers = new ArrayList<>(4);
|
|
this.mLayoutWidget = new ConstraintWidgetContainer();
|
|
this.mMinWidth = 0;
|
|
this.mMinHeight = 0;
|
|
this.mMaxWidth = Integer.MAX_VALUE;
|
|
this.mMaxHeight = Integer.MAX_VALUE;
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
this.mOptimizationLevel = 257;
|
|
this.mConstraintSet = null;
|
|
this.mConstraintLayoutSpec = null;
|
|
this.mConstraintSetId = -1;
|
|
this.mDesignIds = new HashMap<>();
|
|
this.mLastMeasureWidth = -1;
|
|
this.mLastMeasureHeight = -1;
|
|
this.mLastMeasureWidthSize = -1;
|
|
this.mLastMeasureHeightSize = -1;
|
|
this.mLastMeasureWidthMode = 0;
|
|
this.mLastMeasureHeightMode = 0;
|
|
this.mTempMapIdToWidget = new SparseArray<>();
|
|
this.mMeasurer = new Measurer(this);
|
|
this.mOnMeasureWidthMeasureSpec = 0;
|
|
this.mOnMeasureHeightMeasureSpec = 0;
|
|
init(attrs, 0, 0);
|
|
}
|
|
|
|
public ConstraintLayout(Context context, AttributeSet attrs, int defStyleAttr) {
|
|
super(context, attrs, defStyleAttr);
|
|
this.mChildrenByIds = new SparseArray<>();
|
|
this.mConstraintHelpers = new ArrayList<>(4);
|
|
this.mLayoutWidget = new ConstraintWidgetContainer();
|
|
this.mMinWidth = 0;
|
|
this.mMinHeight = 0;
|
|
this.mMaxWidth = Integer.MAX_VALUE;
|
|
this.mMaxHeight = Integer.MAX_VALUE;
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
this.mOptimizationLevel = 257;
|
|
this.mConstraintSet = null;
|
|
this.mConstraintLayoutSpec = null;
|
|
this.mConstraintSetId = -1;
|
|
this.mDesignIds = new HashMap<>();
|
|
this.mLastMeasureWidth = -1;
|
|
this.mLastMeasureHeight = -1;
|
|
this.mLastMeasureWidthSize = -1;
|
|
this.mLastMeasureHeightSize = -1;
|
|
this.mLastMeasureWidthMode = 0;
|
|
this.mLastMeasureHeightMode = 0;
|
|
this.mTempMapIdToWidget = new SparseArray<>();
|
|
this.mMeasurer = new Measurer(this);
|
|
this.mOnMeasureWidthMeasureSpec = 0;
|
|
this.mOnMeasureHeightMeasureSpec = 0;
|
|
init(attrs, defStyleAttr, 0);
|
|
}
|
|
|
|
public ConstraintLayout(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
|
|
super(context, attrs, defStyleAttr, defStyleRes);
|
|
this.mChildrenByIds = new SparseArray<>();
|
|
this.mConstraintHelpers = new ArrayList<>(4);
|
|
this.mLayoutWidget = new ConstraintWidgetContainer();
|
|
this.mMinWidth = 0;
|
|
this.mMinHeight = 0;
|
|
this.mMaxWidth = Integer.MAX_VALUE;
|
|
this.mMaxHeight = Integer.MAX_VALUE;
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
this.mOptimizationLevel = 257;
|
|
this.mConstraintSet = null;
|
|
this.mConstraintLayoutSpec = null;
|
|
this.mConstraintSetId = -1;
|
|
this.mDesignIds = new HashMap<>();
|
|
this.mLastMeasureWidth = -1;
|
|
this.mLastMeasureHeight = -1;
|
|
this.mLastMeasureWidthSize = -1;
|
|
this.mLastMeasureHeightSize = -1;
|
|
this.mLastMeasureWidthMode = 0;
|
|
this.mLastMeasureHeightMode = 0;
|
|
this.mTempMapIdToWidget = new SparseArray<>();
|
|
this.mMeasurer = new Measurer(this);
|
|
this.mOnMeasureWidthMeasureSpec = 0;
|
|
this.mOnMeasureHeightMeasureSpec = 0;
|
|
init(attrs, defStyleAttr, defStyleRes);
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void setId(int id) {
|
|
this.mChildrenByIds.remove(getId());
|
|
super.setId(id);
|
|
this.mChildrenByIds.put(getId(), this);
|
|
}
|
|
|
|
class Measurer implements BasicMeasure.Measurer {
|
|
ConstraintLayout layout;
|
|
int layoutHeightSpec;
|
|
int layoutWidthSpec;
|
|
int paddingBottom;
|
|
int paddingHeight;
|
|
int paddingTop;
|
|
int paddingWidth;
|
|
|
|
public void captureLayoutInfo(int widthSpec, int heightSpec, int top, int bottom, int width, int height) {
|
|
this.paddingTop = top;
|
|
this.paddingBottom = bottom;
|
|
this.paddingWidth = width;
|
|
this.paddingHeight = height;
|
|
this.layoutWidthSpec = widthSpec;
|
|
this.layoutHeightSpec = heightSpec;
|
|
}
|
|
|
|
public Measurer(ConstraintLayout l) {
|
|
this.layout = l;
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer
|
|
public final void measure(ConstraintWidget widget, BasicMeasure.Measure measure) {
|
|
int makeMeasureSpec;
|
|
int makeMeasureSpec2;
|
|
int baseline;
|
|
int max;
|
|
int i;
|
|
int i2;
|
|
int i3;
|
|
if (widget == null) {
|
|
return;
|
|
}
|
|
if (widget.getVisibility() == 8 && !widget.isInPlaceholder()) {
|
|
measure.measuredWidth = 0;
|
|
measure.measuredHeight = 0;
|
|
measure.measuredBaseline = 0;
|
|
return;
|
|
}
|
|
if (widget.getParent() == null) {
|
|
return;
|
|
}
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour = measure.horizontalBehavior;
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour2 = measure.verticalBehavior;
|
|
int i4 = measure.horizontalDimension;
|
|
int i5 = measure.verticalDimension;
|
|
int i6 = this.paddingTop + this.paddingBottom;
|
|
int i7 = this.paddingWidth;
|
|
View view = (View) widget.getCompanionWidget();
|
|
int i8 = AnonymousClass1.$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour[dimensionBehaviour.ordinal()];
|
|
if (i8 == 1) {
|
|
makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(i4, BasicMeasure.EXACTLY);
|
|
} else if (i8 == 2) {
|
|
makeMeasureSpec = ViewGroup.getChildMeasureSpec(this.layoutWidthSpec, i7, -2);
|
|
} else if (i8 == 3) {
|
|
makeMeasureSpec = ViewGroup.getChildMeasureSpec(this.layoutWidthSpec, i7 + widget.getHorizontalMargin(), -1);
|
|
} else if (i8 != 4) {
|
|
makeMeasureSpec = 0;
|
|
} else {
|
|
makeMeasureSpec = ViewGroup.getChildMeasureSpec(this.layoutWidthSpec, i7, -2);
|
|
boolean z = widget.mMatchConstraintDefaultWidth == 1 ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
if (measure.measureStrategy == BasicMeasure.Measure.TRY_GIVEN_DIMENSIONS || measure.measureStrategy == BasicMeasure.Measure.USE_GIVEN_DIMENSIONS) {
|
|
boolean z2 = view.getMeasuredHeight() == widget.getHeight() ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
if (measure.measureStrategy == BasicMeasure.Measure.USE_GIVEN_DIMENSIONS || !z || ((z && z2) || (view instanceof Placeholder) || widget.isResolvedHorizontally())) {
|
|
makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(widget.getWidth(), BasicMeasure.EXACTLY);
|
|
}
|
|
}
|
|
}
|
|
int i9 = AnonymousClass1.$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour[dimensionBehaviour2.ordinal()];
|
|
if (i9 == 1) {
|
|
makeMeasureSpec2 = View.MeasureSpec.makeMeasureSpec(i5, BasicMeasure.EXACTLY);
|
|
} else if (i9 == 2) {
|
|
makeMeasureSpec2 = ViewGroup.getChildMeasureSpec(this.layoutHeightSpec, i6, -2);
|
|
} else if (i9 == 3) {
|
|
makeMeasureSpec2 = ViewGroup.getChildMeasureSpec(this.layoutHeightSpec, i6 + widget.getVerticalMargin(), -1);
|
|
} else if (i9 != 4) {
|
|
makeMeasureSpec2 = 0;
|
|
} else {
|
|
makeMeasureSpec2 = ViewGroup.getChildMeasureSpec(this.layoutHeightSpec, i6, -2);
|
|
boolean z3 = widget.mMatchConstraintDefaultHeight == 1 ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
if (measure.measureStrategy == BasicMeasure.Measure.TRY_GIVEN_DIMENSIONS || measure.measureStrategy == BasicMeasure.Measure.USE_GIVEN_DIMENSIONS) {
|
|
boolean z4 = view.getMeasuredWidth() == widget.getWidth() ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
if (measure.measureStrategy == BasicMeasure.Measure.USE_GIVEN_DIMENSIONS || !z3 || ((z3 && z4) || (view instanceof Placeholder) || widget.isResolvedVertically())) {
|
|
makeMeasureSpec2 = View.MeasureSpec.makeMeasureSpec(widget.getHeight(), BasicMeasure.EXACTLY);
|
|
}
|
|
}
|
|
}
|
|
ConstraintWidgetContainer constraintWidgetContainer = (ConstraintWidgetContainer) widget.getParent();
|
|
if (constraintWidgetContainer != null && Optimizer.enabled(ConstraintLayout.this.mOptimizationLevel, 256) && view.getMeasuredWidth() == widget.getWidth() && view.getMeasuredWidth() < constraintWidgetContainer.getWidth() && view.getMeasuredHeight() == widget.getHeight() && view.getMeasuredHeight() < constraintWidgetContainer.getHeight() && view.getBaseline() == widget.getBaselineDistance() && !widget.isMeasureRequested() && isSimilarSpec(widget.getLastHorizontalMeasureSpec(), makeMeasureSpec, widget.getWidth()) && isSimilarSpec(widget.getLastVerticalMeasureSpec(), makeMeasureSpec2, widget.getHeight())) {
|
|
measure.measuredWidth = widget.getWidth();
|
|
measure.measuredHeight = widget.getHeight();
|
|
measure.measuredBaseline = widget.getBaselineDistance();
|
|
return;
|
|
}
|
|
boolean z5 = dimensionBehaviour == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
boolean z6 = dimensionBehaviour2 == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
boolean z7 = (dimensionBehaviour2 == ConstraintWidget.DimensionBehaviour.MATCH_PARENT || dimensionBehaviour2 == ConstraintWidget.DimensionBehaviour.FIXED) ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
boolean z8 = (dimensionBehaviour == ConstraintWidget.DimensionBehaviour.MATCH_PARENT || dimensionBehaviour == ConstraintWidget.DimensionBehaviour.FIXED) ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
boolean z9 = (!z5 || widget.mDimensionRatio <= 0.0f) ? false : ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
boolean z10 = (!z6 || widget.mDimensionRatio <= 0.0f) ? false : ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
if (view == null) {
|
|
return;
|
|
}
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
if (measure.measureStrategy != BasicMeasure.Measure.TRY_GIVEN_DIMENSIONS && measure.measureStrategy != BasicMeasure.Measure.USE_GIVEN_DIMENSIONS && z5 && widget.mMatchConstraintDefaultWidth == 0 && z6 && widget.mMatchConstraintDefaultHeight == 0) {
|
|
i3 = -1;
|
|
baseline = 0;
|
|
max = 0;
|
|
i2 = 0;
|
|
} else {
|
|
if ((view instanceof VirtualLayout) && (widget instanceof androidx.constraintlayout.core.widgets.VirtualLayout)) {
|
|
((VirtualLayout) view).onMeasure((androidx.constraintlayout.core.widgets.VirtualLayout) widget, makeMeasureSpec, makeMeasureSpec2);
|
|
} else {
|
|
view.measure(makeMeasureSpec, makeMeasureSpec2);
|
|
}
|
|
widget.setLastMeasureSpec(makeMeasureSpec, makeMeasureSpec2);
|
|
int measuredWidth = view.getMeasuredWidth();
|
|
int measuredHeight = view.getMeasuredHeight();
|
|
baseline = view.getBaseline();
|
|
max = widget.mMatchConstraintMinWidth > 0 ? Math.max(widget.mMatchConstraintMinWidth, measuredWidth) : measuredWidth;
|
|
if (widget.mMatchConstraintMaxWidth > 0) {
|
|
max = Math.min(widget.mMatchConstraintMaxWidth, max);
|
|
}
|
|
if (widget.mMatchConstraintMinHeight > 0) {
|
|
i2 = Math.max(widget.mMatchConstraintMinHeight, measuredHeight);
|
|
i = makeMeasureSpec2;
|
|
} else {
|
|
i = makeMeasureSpec2;
|
|
i2 = measuredHeight;
|
|
}
|
|
if (widget.mMatchConstraintMaxHeight > 0) {
|
|
i2 = Math.min(widget.mMatchConstraintMaxHeight, i2);
|
|
}
|
|
if (!Optimizer.enabled(ConstraintLayout.this.mOptimizationLevel, 1)) {
|
|
if (z9 && z7) {
|
|
max = (int) ((i2 * widget.mDimensionRatio) + 0.5f);
|
|
} else if (z10 && z8) {
|
|
i2 = (int) ((max / widget.mDimensionRatio) + 0.5f);
|
|
}
|
|
}
|
|
if (measuredWidth != max || measuredHeight != i2) {
|
|
if (measuredWidth != max) {
|
|
makeMeasureSpec = View.MeasureSpec.makeMeasureSpec(max, BasicMeasure.EXACTLY);
|
|
}
|
|
int makeMeasureSpec3 = measuredHeight != i2 ? View.MeasureSpec.makeMeasureSpec(i2, BasicMeasure.EXACTLY) : i;
|
|
view.measure(makeMeasureSpec, makeMeasureSpec3);
|
|
widget.setLastMeasureSpec(makeMeasureSpec, makeMeasureSpec3);
|
|
max = view.getMeasuredWidth();
|
|
i2 = view.getMeasuredHeight();
|
|
baseline = view.getBaseline();
|
|
}
|
|
i3 = -1;
|
|
}
|
|
boolean z11 = baseline != i3 ? ConstraintLayout.USE_CONSTRAINTS_HELPER : false;
|
|
measure.measuredNeedsSolverPass = (max == measure.horizontalDimension && i2 == measure.verticalDimension) ? false : ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
if (layoutParams.needsBaseline) {
|
|
z11 = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
if (z11 && baseline != -1 && widget.getBaselineDistance() != baseline) {
|
|
measure.measuredNeedsSolverPass = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
measure.measuredWidth = max;
|
|
measure.measuredHeight = i2;
|
|
measure.measuredHasBaseline = z11;
|
|
measure.measuredBaseline = baseline;
|
|
}
|
|
|
|
private boolean isSimilarSpec(int lastMeasureSpec, int spec, int widgetSize) {
|
|
if (lastMeasureSpec == spec) {
|
|
return ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
int mode = View.MeasureSpec.getMode(lastMeasureSpec);
|
|
View.MeasureSpec.getSize(lastMeasureSpec);
|
|
int mode2 = View.MeasureSpec.getMode(spec);
|
|
int size = View.MeasureSpec.getSize(spec);
|
|
if (mode2 != 1073741824) {
|
|
return false;
|
|
}
|
|
if ((mode == Integer.MIN_VALUE || mode == 0) && widgetSize == size) {
|
|
return ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.core.widgets.analyzer.BasicMeasure.Measurer
|
|
public final void didMeasures() {
|
|
int childCount = this.layout.getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = this.layout.getChildAt(i);
|
|
if (childAt instanceof Placeholder) {
|
|
((Placeholder) childAt).updatePostMeasure(this.layout);
|
|
}
|
|
}
|
|
int size = this.layout.mConstraintHelpers.size();
|
|
if (size > 0) {
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
((ConstraintHelper) this.layout.mConstraintHelpers.get(i2)).updatePostMeasure(this.layout);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* renamed from: androidx.constraintlayout.widget.ConstraintLayout$1, reason: invalid class name */
|
|
static /* synthetic */ class AnonymousClass1 {
|
|
static final /* synthetic */ int[] $SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour;
|
|
|
|
static {
|
|
int[] iArr = new int[ConstraintWidget.DimensionBehaviour.values().length];
|
|
$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour = iArr;
|
|
try {
|
|
iArr[ConstraintWidget.DimensionBehaviour.FIXED.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour[ConstraintWidget.DimensionBehaviour.WRAP_CONTENT.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour[ConstraintWidget.DimensionBehaviour.MATCH_PARENT.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$core$widgets$ConstraintWidget$DimensionBehaviour[ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
}
|
|
}
|
|
|
|
private void init(AttributeSet attrs, int defStyleAttr, int defStyleRes) {
|
|
this.mLayoutWidget.setCompanionWidget(this);
|
|
this.mLayoutWidget.setMeasurer(this.mMeasurer);
|
|
this.mChildrenByIds.put(getId(), this);
|
|
this.mConstraintSet = null;
|
|
if (attrs != null) {
|
|
TypedArray obtainStyledAttributes = getContext().obtainStyledAttributes(attrs, R.styleable.ConstraintLayout_Layout, defStyleAttr, defStyleRes);
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
if (index == R.styleable.ConstraintLayout_Layout_android_minWidth) {
|
|
this.mMinWidth = obtainStyledAttributes.getDimensionPixelOffset(index, this.mMinWidth);
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_android_minHeight) {
|
|
this.mMinHeight = obtainStyledAttributes.getDimensionPixelOffset(index, this.mMinHeight);
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_android_maxWidth) {
|
|
this.mMaxWidth = obtainStyledAttributes.getDimensionPixelOffset(index, this.mMaxWidth);
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_android_maxHeight) {
|
|
this.mMaxHeight = obtainStyledAttributes.getDimensionPixelOffset(index, this.mMaxHeight);
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_layout_optimizationLevel) {
|
|
this.mOptimizationLevel = obtainStyledAttributes.getInt(index, this.mOptimizationLevel);
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_layoutDescription) {
|
|
int resourceId = obtainStyledAttributes.getResourceId(index, 0);
|
|
if (resourceId != 0) {
|
|
try {
|
|
parseLayoutDescription(resourceId);
|
|
} catch (Resources.NotFoundException unused) {
|
|
this.mConstraintLayoutSpec = null;
|
|
}
|
|
}
|
|
} else if (index == R.styleable.ConstraintLayout_Layout_constraintSet) {
|
|
int resourceId2 = obtainStyledAttributes.getResourceId(index, 0);
|
|
try {
|
|
ConstraintSet constraintSet = new ConstraintSet();
|
|
this.mConstraintSet = constraintSet;
|
|
constraintSet.load(getContext(), resourceId2);
|
|
} catch (Resources.NotFoundException unused2) {
|
|
this.mConstraintSet = null;
|
|
}
|
|
this.mConstraintSetId = resourceId2;
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
this.mLayoutWidget.setOptimizationLevel(this.mOptimizationLevel);
|
|
}
|
|
|
|
protected void parseLayoutDescription(int id) {
|
|
this.mConstraintLayoutSpec = new ConstraintLayoutStates(getContext(), this, id);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public void onViewAdded(View view) {
|
|
super.onViewAdded(view);
|
|
ConstraintWidget viewWidget = getViewWidget(view);
|
|
if ((view instanceof Guideline) && !(viewWidget instanceof androidx.constraintlayout.core.widgets.Guideline)) {
|
|
LayoutParams layoutParams = (LayoutParams) view.getLayoutParams();
|
|
layoutParams.widget = new androidx.constraintlayout.core.widgets.Guideline();
|
|
layoutParams.isGuideline = USE_CONSTRAINTS_HELPER;
|
|
((androidx.constraintlayout.core.widgets.Guideline) layoutParams.widget).setOrientation(layoutParams.orientation);
|
|
}
|
|
if (view instanceof ConstraintHelper) {
|
|
ConstraintHelper constraintHelper = (ConstraintHelper) view;
|
|
constraintHelper.validateParams();
|
|
((LayoutParams) view.getLayoutParams()).isHelper = USE_CONSTRAINTS_HELPER;
|
|
if (!this.mConstraintHelpers.contains(constraintHelper)) {
|
|
this.mConstraintHelpers.add(constraintHelper);
|
|
}
|
|
}
|
|
this.mChildrenByIds.put(view.getId(), view);
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public void onViewRemoved(View view) {
|
|
super.onViewRemoved(view);
|
|
this.mChildrenByIds.remove(view.getId());
|
|
this.mLayoutWidget.remove(getViewWidget(view));
|
|
this.mConstraintHelpers.remove(view);
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
}
|
|
|
|
public void setMinWidth(int value) {
|
|
if (value == this.mMinWidth) {
|
|
return;
|
|
}
|
|
this.mMinWidth = value;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setMinHeight(int value) {
|
|
if (value == this.mMinHeight) {
|
|
return;
|
|
}
|
|
this.mMinHeight = value;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setMaxWidth(int value) {
|
|
if (value == this.mMaxWidth) {
|
|
return;
|
|
}
|
|
this.mMaxWidth = value;
|
|
requestLayout();
|
|
}
|
|
|
|
public void setMaxHeight(int value) {
|
|
if (value == this.mMaxHeight) {
|
|
return;
|
|
}
|
|
this.mMaxHeight = value;
|
|
requestLayout();
|
|
}
|
|
|
|
private boolean updateHierarchy() {
|
|
int childCount = getChildCount();
|
|
boolean z = false;
|
|
int i = 0;
|
|
while (true) {
|
|
if (i >= childCount) {
|
|
break;
|
|
}
|
|
if (getChildAt(i).isLayoutRequested()) {
|
|
z = USE_CONSTRAINTS_HELPER;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
if (z) {
|
|
setChildrenConstraints();
|
|
}
|
|
return z;
|
|
}
|
|
|
|
private void setChildrenConstraints() {
|
|
boolean isInEditMode = isInEditMode();
|
|
int childCount = getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
ConstraintWidget viewWidget = getViewWidget(getChildAt(i));
|
|
if (viewWidget != null) {
|
|
viewWidget.reset();
|
|
}
|
|
}
|
|
if (isInEditMode) {
|
|
for (int i2 = 0; i2 < childCount; i2++) {
|
|
View childAt = getChildAt(i2);
|
|
try {
|
|
String resourceName = getResources().getResourceName(childAt.getId());
|
|
setDesignInformation(0, resourceName, Integer.valueOf(childAt.getId()));
|
|
int indexOf = resourceName.indexOf(47);
|
|
if (indexOf != -1) {
|
|
resourceName = resourceName.substring(indexOf + 1);
|
|
}
|
|
getTargetWidget(childAt.getId()).setDebugName(resourceName);
|
|
} catch (Resources.NotFoundException unused) {
|
|
}
|
|
}
|
|
}
|
|
if (this.mConstraintSetId != -1) {
|
|
for (int i3 = 0; i3 < childCount; i3++) {
|
|
View childAt2 = getChildAt(i3);
|
|
if (childAt2.getId() == this.mConstraintSetId && (childAt2 instanceof Constraints)) {
|
|
this.mConstraintSet = ((Constraints) childAt2).getConstraintSet();
|
|
}
|
|
}
|
|
}
|
|
ConstraintSet constraintSet = this.mConstraintSet;
|
|
if (constraintSet != null) {
|
|
constraintSet.applyToInternal(this, USE_CONSTRAINTS_HELPER);
|
|
}
|
|
this.mLayoutWidget.removeAllChildren();
|
|
int size = this.mConstraintHelpers.size();
|
|
if (size > 0) {
|
|
for (int i4 = 0; i4 < size; i4++) {
|
|
this.mConstraintHelpers.get(i4).updatePreLayout(this);
|
|
}
|
|
}
|
|
for (int i5 = 0; i5 < childCount; i5++) {
|
|
View childAt3 = getChildAt(i5);
|
|
if (childAt3 instanceof Placeholder) {
|
|
((Placeholder) childAt3).updatePreLayout(this);
|
|
}
|
|
}
|
|
this.mTempMapIdToWidget.clear();
|
|
this.mTempMapIdToWidget.put(0, this.mLayoutWidget);
|
|
this.mTempMapIdToWidget.put(getId(), this.mLayoutWidget);
|
|
for (int i6 = 0; i6 < childCount; i6++) {
|
|
View childAt4 = getChildAt(i6);
|
|
this.mTempMapIdToWidget.put(childAt4.getId(), getViewWidget(childAt4));
|
|
}
|
|
for (int i7 = 0; i7 < childCount; i7++) {
|
|
View childAt5 = getChildAt(i7);
|
|
ConstraintWidget viewWidget2 = getViewWidget(childAt5);
|
|
if (viewWidget2 != null) {
|
|
LayoutParams layoutParams = (LayoutParams) childAt5.getLayoutParams();
|
|
this.mLayoutWidget.add(viewWidget2);
|
|
applyConstraintsFromLayoutParams(isInEditMode, childAt5, viewWidget2, layoutParams, this.mTempMapIdToWidget);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public void applyConstraintsFromLayoutParams(boolean isInEditMode, View child, ConstraintWidget widget, LayoutParams layoutParams, SparseArray<ConstraintWidget> idToWidget) {
|
|
ConstraintWidget constraintWidget;
|
|
ConstraintWidget constraintWidget2;
|
|
ConstraintWidget constraintWidget3;
|
|
ConstraintWidget constraintWidget4;
|
|
layoutParams.validate();
|
|
layoutParams.helped = false;
|
|
widget.setVisibility(child.getVisibility());
|
|
if (layoutParams.isInPlaceholder) {
|
|
widget.setInPlaceholder(USE_CONSTRAINTS_HELPER);
|
|
widget.setVisibility(8);
|
|
}
|
|
widget.setCompanionWidget(child);
|
|
if (child instanceof ConstraintHelper) {
|
|
((ConstraintHelper) child).resolveRtl(widget, this.mLayoutWidget.isRtl());
|
|
}
|
|
if (layoutParams.isGuideline) {
|
|
androidx.constraintlayout.core.widgets.Guideline guideline = (androidx.constraintlayout.core.widgets.Guideline) widget;
|
|
int i = layoutParams.resolvedGuideBegin;
|
|
int i2 = layoutParams.resolvedGuideEnd;
|
|
float f = layoutParams.resolvedGuidePercent;
|
|
if (f != -1.0f) {
|
|
guideline.setGuidePercent(f);
|
|
return;
|
|
} else if (i != -1) {
|
|
guideline.setGuideBegin(i);
|
|
return;
|
|
} else {
|
|
if (i2 != -1) {
|
|
guideline.setGuideEnd(i2);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
int i3 = layoutParams.resolvedLeftToLeft;
|
|
int i4 = layoutParams.resolvedLeftToRight;
|
|
int i5 = layoutParams.resolvedRightToLeft;
|
|
int i6 = layoutParams.resolvedRightToRight;
|
|
int i7 = layoutParams.resolveGoneLeftMargin;
|
|
int i8 = layoutParams.resolveGoneRightMargin;
|
|
float f2 = layoutParams.resolvedHorizontalBias;
|
|
if (layoutParams.circleConstraint != -1) {
|
|
ConstraintWidget constraintWidget5 = idToWidget.get(layoutParams.circleConstraint);
|
|
if (constraintWidget5 != null) {
|
|
widget.connectCircularConstraint(constraintWidget5, layoutParams.circleAngle, layoutParams.circleRadius);
|
|
}
|
|
} else {
|
|
if (i3 != -1) {
|
|
ConstraintWidget constraintWidget6 = idToWidget.get(i3);
|
|
if (constraintWidget6 != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.LEFT, constraintWidget6, ConstraintAnchor.Type.LEFT, layoutParams.leftMargin, i7);
|
|
}
|
|
} else if (i4 != -1 && (constraintWidget = idToWidget.get(i4)) != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.LEFT, constraintWidget, ConstraintAnchor.Type.RIGHT, layoutParams.leftMargin, i7);
|
|
}
|
|
if (i5 != -1) {
|
|
ConstraintWidget constraintWidget7 = idToWidget.get(i5);
|
|
if (constraintWidget7 != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.RIGHT, constraintWidget7, ConstraintAnchor.Type.LEFT, layoutParams.rightMargin, i8);
|
|
}
|
|
} else if (i6 != -1 && (constraintWidget2 = idToWidget.get(i6)) != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.RIGHT, constraintWidget2, ConstraintAnchor.Type.RIGHT, layoutParams.rightMargin, i8);
|
|
}
|
|
if (layoutParams.topToTop != -1) {
|
|
ConstraintWidget constraintWidget8 = idToWidget.get(layoutParams.topToTop);
|
|
if (constraintWidget8 != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.TOP, constraintWidget8, ConstraintAnchor.Type.TOP, layoutParams.topMargin, layoutParams.goneTopMargin);
|
|
}
|
|
} else if (layoutParams.topToBottom != -1 && (constraintWidget3 = idToWidget.get(layoutParams.topToBottom)) != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.TOP, constraintWidget3, ConstraintAnchor.Type.BOTTOM, layoutParams.topMargin, layoutParams.goneTopMargin);
|
|
}
|
|
if (layoutParams.bottomToTop != -1) {
|
|
ConstraintWidget constraintWidget9 = idToWidget.get(layoutParams.bottomToTop);
|
|
if (constraintWidget9 != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.BOTTOM, constraintWidget9, ConstraintAnchor.Type.TOP, layoutParams.bottomMargin, layoutParams.goneBottomMargin);
|
|
}
|
|
} else if (layoutParams.bottomToBottom != -1 && (constraintWidget4 = idToWidget.get(layoutParams.bottomToBottom)) != null) {
|
|
widget.immediateConnect(ConstraintAnchor.Type.BOTTOM, constraintWidget4, ConstraintAnchor.Type.BOTTOM, layoutParams.bottomMargin, layoutParams.goneBottomMargin);
|
|
}
|
|
if (layoutParams.baselineToBaseline != -1) {
|
|
setWidgetBaseline(widget, layoutParams, idToWidget, layoutParams.baselineToBaseline, ConstraintAnchor.Type.BASELINE);
|
|
} else if (layoutParams.baselineToTop != -1) {
|
|
setWidgetBaseline(widget, layoutParams, idToWidget, layoutParams.baselineToTop, ConstraintAnchor.Type.TOP);
|
|
} else if (layoutParams.baselineToBottom != -1) {
|
|
setWidgetBaseline(widget, layoutParams, idToWidget, layoutParams.baselineToBottom, ConstraintAnchor.Type.BOTTOM);
|
|
}
|
|
if (f2 >= 0.0f) {
|
|
widget.setHorizontalBiasPercent(f2);
|
|
}
|
|
if (layoutParams.verticalBias >= 0.0f) {
|
|
widget.setVerticalBiasPercent(layoutParams.verticalBias);
|
|
}
|
|
}
|
|
if (isInEditMode && (layoutParams.editorAbsoluteX != -1 || layoutParams.editorAbsoluteY != -1)) {
|
|
widget.setOrigin(layoutParams.editorAbsoluteX, layoutParams.editorAbsoluteY);
|
|
}
|
|
if (!layoutParams.horizontalDimensionFixed) {
|
|
if (layoutParams.width == -1) {
|
|
if (layoutParams.constrainedWidth) {
|
|
widget.setHorizontalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT);
|
|
} else {
|
|
widget.setHorizontalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_PARENT);
|
|
}
|
|
widget.getAnchor(ConstraintAnchor.Type.LEFT).mMargin = layoutParams.leftMargin;
|
|
widget.getAnchor(ConstraintAnchor.Type.RIGHT).mMargin = layoutParams.rightMargin;
|
|
} else {
|
|
widget.setHorizontalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT);
|
|
widget.setWidth(0);
|
|
}
|
|
} else {
|
|
widget.setHorizontalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.FIXED);
|
|
widget.setWidth(layoutParams.width);
|
|
if (layoutParams.width == -2) {
|
|
widget.setHorizontalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.WRAP_CONTENT);
|
|
}
|
|
}
|
|
if (!layoutParams.verticalDimensionFixed) {
|
|
if (layoutParams.height == -1) {
|
|
if (layoutParams.constrainedHeight) {
|
|
widget.setVerticalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT);
|
|
} else {
|
|
widget.setVerticalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_PARENT);
|
|
}
|
|
widget.getAnchor(ConstraintAnchor.Type.TOP).mMargin = layoutParams.topMargin;
|
|
widget.getAnchor(ConstraintAnchor.Type.BOTTOM).mMargin = layoutParams.bottomMargin;
|
|
} else {
|
|
widget.setVerticalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT);
|
|
widget.setHeight(0);
|
|
}
|
|
} else {
|
|
widget.setVerticalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.FIXED);
|
|
widget.setHeight(layoutParams.height);
|
|
if (layoutParams.height == -2) {
|
|
widget.setVerticalDimensionBehaviour(ConstraintWidget.DimensionBehaviour.WRAP_CONTENT);
|
|
}
|
|
}
|
|
widget.setDimensionRatio(layoutParams.dimensionRatio);
|
|
widget.setHorizontalWeight(layoutParams.horizontalWeight);
|
|
widget.setVerticalWeight(layoutParams.verticalWeight);
|
|
widget.setHorizontalChainStyle(layoutParams.horizontalChainStyle);
|
|
widget.setVerticalChainStyle(layoutParams.verticalChainStyle);
|
|
widget.setWrapBehaviorInParent(layoutParams.wrapBehaviorInParent);
|
|
widget.setHorizontalMatchStyle(layoutParams.matchConstraintDefaultWidth, layoutParams.matchConstraintMinWidth, layoutParams.matchConstraintMaxWidth, layoutParams.matchConstraintPercentWidth);
|
|
widget.setVerticalMatchStyle(layoutParams.matchConstraintDefaultHeight, layoutParams.matchConstraintMinHeight, layoutParams.matchConstraintMaxHeight, layoutParams.matchConstraintPercentHeight);
|
|
}
|
|
|
|
private void setWidgetBaseline(ConstraintWidget widget, LayoutParams layoutParams, SparseArray<ConstraintWidget> idToWidget, int baselineTarget, ConstraintAnchor.Type type) {
|
|
View view = this.mChildrenByIds.get(baselineTarget);
|
|
ConstraintWidget constraintWidget = idToWidget.get(baselineTarget);
|
|
if (constraintWidget == null || view == null || !(view.getLayoutParams() instanceof LayoutParams)) {
|
|
return;
|
|
}
|
|
layoutParams.needsBaseline = USE_CONSTRAINTS_HELPER;
|
|
if (type == ConstraintAnchor.Type.BASELINE) {
|
|
LayoutParams layoutParams2 = (LayoutParams) view.getLayoutParams();
|
|
layoutParams2.needsBaseline = USE_CONSTRAINTS_HELPER;
|
|
layoutParams2.widget.setHasBaseline(USE_CONSTRAINTS_HELPER);
|
|
}
|
|
widget.getAnchor(ConstraintAnchor.Type.BASELINE).connect(constraintWidget.getAnchor(type), layoutParams.baselineMargin, layoutParams.goneBaselineMargin, USE_CONSTRAINTS_HELPER);
|
|
widget.setHasBaseline(USE_CONSTRAINTS_HELPER);
|
|
widget.getAnchor(ConstraintAnchor.Type.TOP).reset();
|
|
widget.getAnchor(ConstraintAnchor.Type.BOTTOM).reset();
|
|
}
|
|
|
|
private final ConstraintWidget getTargetWidget(int id) {
|
|
if (id == 0) {
|
|
return this.mLayoutWidget;
|
|
}
|
|
View view = this.mChildrenByIds.get(id);
|
|
if (view == null && (view = findViewById(id)) != null && view != this && view.getParent() == this) {
|
|
onViewAdded(view);
|
|
}
|
|
if (view == this) {
|
|
return this.mLayoutWidget;
|
|
}
|
|
if (view == null) {
|
|
return null;
|
|
}
|
|
return ((LayoutParams) view.getLayoutParams()).widget;
|
|
}
|
|
|
|
public final ConstraintWidget getViewWidget(View view) {
|
|
if (view == this) {
|
|
return this.mLayoutWidget;
|
|
}
|
|
if (view == null) {
|
|
return null;
|
|
}
|
|
if (view.getLayoutParams() instanceof LayoutParams) {
|
|
return ((LayoutParams) view.getLayoutParams()).widget;
|
|
}
|
|
view.setLayoutParams(generateLayoutParams(view.getLayoutParams()));
|
|
if (view.getLayoutParams() instanceof LayoutParams) {
|
|
return ((LayoutParams) view.getLayoutParams()).widget;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void fillMetrics(Metrics metrics) {
|
|
this.mMetrics = metrics;
|
|
this.mLayoutWidget.fillMetrics(metrics);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public void resolveSystem(ConstraintWidgetContainer layout, int optimizationLevel, int widthMeasureSpec, int heightMeasureSpec) {
|
|
int i;
|
|
int mode = View.MeasureSpec.getMode(widthMeasureSpec);
|
|
int size = View.MeasureSpec.getSize(widthMeasureSpec);
|
|
int mode2 = View.MeasureSpec.getMode(heightMeasureSpec);
|
|
int size2 = View.MeasureSpec.getSize(heightMeasureSpec);
|
|
int max = Math.max(0, getPaddingTop());
|
|
int max2 = Math.max(0, getPaddingBottom());
|
|
int i2 = max + max2;
|
|
int paddingWidth = getPaddingWidth();
|
|
this.mMeasurer.captureLayoutInfo(widthMeasureSpec, heightMeasureSpec, max, max2, paddingWidth, i2);
|
|
int max3 = Math.max(0, getPaddingStart());
|
|
int max4 = Math.max(0, getPaddingEnd());
|
|
if (max3 > 0 || max4 > 0) {
|
|
i = isRtl() ? max4 : max3;
|
|
} else {
|
|
i = Math.max(0, getPaddingLeft());
|
|
}
|
|
int i3 = size - paddingWidth;
|
|
int i4 = size2 - i2;
|
|
setSelfDimensionBehaviour(layout, mode, i3, mode2, i4);
|
|
layout.measure(optimizationLevel, mode, i3, mode2, i4, this.mLastMeasureWidth, this.mLastMeasureHeight, i, max);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public void resolveMeasuredDimension(int widthMeasureSpec, int heightMeasureSpec, int measuredWidth, int measuredHeight, boolean isWidthMeasuredTooSmall, boolean isHeightMeasuredTooSmall) {
|
|
int i = this.mMeasurer.paddingHeight;
|
|
int resolveSizeAndState = resolveSizeAndState(measuredWidth + this.mMeasurer.paddingWidth, widthMeasureSpec, 0);
|
|
int resolveSizeAndState2 = resolveSizeAndState(measuredHeight + i, heightMeasureSpec, 0);
|
|
int i2 = resolveSizeAndState & ViewCompat.MEASURED_SIZE_MASK;
|
|
int i3 = resolveSizeAndState2 & ViewCompat.MEASURED_SIZE_MASK;
|
|
int min = Math.min(this.mMaxWidth, i2);
|
|
int min2 = Math.min(this.mMaxHeight, i3);
|
|
if (isWidthMeasuredTooSmall) {
|
|
min |= 16777216;
|
|
}
|
|
if (isHeightMeasuredTooSmall) {
|
|
min2 |= 16777216;
|
|
}
|
|
setMeasuredDimension(min, min2);
|
|
this.mLastMeasureWidth = min;
|
|
this.mLastMeasureHeight = min2;
|
|
}
|
|
|
|
@Override // android.view.View
|
|
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
|
|
if (this.mOnMeasureWidthMeasureSpec == widthMeasureSpec) {
|
|
int i = this.mOnMeasureHeightMeasureSpec;
|
|
}
|
|
if (!this.mDirtyHierarchy) {
|
|
int childCount = getChildCount();
|
|
int i2 = 0;
|
|
while (true) {
|
|
if (i2 >= childCount) {
|
|
break;
|
|
}
|
|
if (getChildAt(i2).isLayoutRequested()) {
|
|
this.mDirtyHierarchy = USE_CONSTRAINTS_HELPER;
|
|
break;
|
|
}
|
|
i2++;
|
|
}
|
|
}
|
|
this.mOnMeasureWidthMeasureSpec = widthMeasureSpec;
|
|
this.mOnMeasureHeightMeasureSpec = heightMeasureSpec;
|
|
this.mLayoutWidget.setRtl(isRtl());
|
|
if (this.mDirtyHierarchy) {
|
|
this.mDirtyHierarchy = false;
|
|
if (updateHierarchy()) {
|
|
this.mLayoutWidget.updateHierarchy();
|
|
}
|
|
}
|
|
resolveSystem(this.mLayoutWidget, this.mOptimizationLevel, widthMeasureSpec, heightMeasureSpec);
|
|
resolveMeasuredDimension(widthMeasureSpec, heightMeasureSpec, this.mLayoutWidget.getWidth(), this.mLayoutWidget.getHeight(), this.mLayoutWidget.isWidthMeasuredTooSmall(), this.mLayoutWidget.isHeightMeasuredTooSmall());
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
public boolean isRtl() {
|
|
if ((getContext().getApplicationInfo().flags & 4194304) == 0 || 1 != getLayoutDirection()) {
|
|
return false;
|
|
}
|
|
return USE_CONSTRAINTS_HELPER;
|
|
}
|
|
|
|
private int getPaddingWidth() {
|
|
int max = Math.max(0, getPaddingLeft()) + Math.max(0, getPaddingRight());
|
|
int max2 = Math.max(0, getPaddingStart()) + Math.max(0, getPaddingEnd());
|
|
return max2 > 0 ? max2 : max;
|
|
}
|
|
|
|
protected void setSelfDimensionBehaviour(ConstraintWidgetContainer layout, int widthMode, int widthSize, int heightMode, int heightSize) {
|
|
int i = this.mMeasurer.paddingHeight;
|
|
int i2 = this.mMeasurer.paddingWidth;
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour = ConstraintWidget.DimensionBehaviour.FIXED;
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.FIXED;
|
|
int childCount = getChildCount();
|
|
if (widthMode == Integer.MIN_VALUE) {
|
|
dimensionBehaviour = ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
|
|
if (childCount == 0) {
|
|
widthSize = Math.max(0, this.mMinWidth);
|
|
}
|
|
} else if (widthMode != 0) {
|
|
if (widthMode == 1073741824) {
|
|
widthSize = Math.min(this.mMaxWidth - i2, widthSize);
|
|
}
|
|
widthSize = 0;
|
|
} else {
|
|
dimensionBehaviour = ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
|
|
if (childCount == 0) {
|
|
widthSize = Math.max(0, this.mMinWidth);
|
|
}
|
|
widthSize = 0;
|
|
}
|
|
if (heightMode == Integer.MIN_VALUE) {
|
|
dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
|
|
if (childCount == 0) {
|
|
heightSize = Math.max(0, this.mMinHeight);
|
|
}
|
|
} else if (heightMode != 0) {
|
|
if (heightMode == 1073741824) {
|
|
heightSize = Math.min(this.mMaxHeight - i, heightSize);
|
|
}
|
|
heightSize = 0;
|
|
} else {
|
|
dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.WRAP_CONTENT;
|
|
if (childCount == 0) {
|
|
heightSize = Math.max(0, this.mMinHeight);
|
|
}
|
|
heightSize = 0;
|
|
}
|
|
if (widthSize != layout.getWidth() || heightSize != layout.getHeight()) {
|
|
layout.invalidateMeasures();
|
|
}
|
|
layout.setX(0);
|
|
layout.setY(0);
|
|
layout.setMaxWidth(this.mMaxWidth - i2);
|
|
layout.setMaxHeight(this.mMaxHeight - i);
|
|
layout.setMinWidth(0);
|
|
layout.setMinHeight(0);
|
|
layout.setHorizontalDimensionBehaviour(dimensionBehaviour);
|
|
layout.setWidth(widthSize);
|
|
layout.setVerticalDimensionBehaviour(dimensionBehaviour2);
|
|
layout.setHeight(heightSize);
|
|
layout.setMinWidth(this.mMinWidth - i2);
|
|
layout.setMinHeight(this.mMinHeight - i);
|
|
}
|
|
|
|
public void setState(int id, int screenWidth, int screenHeight) {
|
|
ConstraintLayoutStates constraintLayoutStates = this.mConstraintLayoutSpec;
|
|
if (constraintLayoutStates != null) {
|
|
constraintLayoutStates.updateConstraints(id, screenWidth, screenHeight);
|
|
}
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
|
|
View content;
|
|
int childCount = getChildCount();
|
|
boolean isInEditMode = isInEditMode();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = getChildAt(i);
|
|
LayoutParams layoutParams = (LayoutParams) childAt.getLayoutParams();
|
|
ConstraintWidget constraintWidget = layoutParams.widget;
|
|
if ((childAt.getVisibility() != 8 || layoutParams.isGuideline || layoutParams.isHelper || layoutParams.isVirtualGroup || isInEditMode) && !layoutParams.isInPlaceholder) {
|
|
int x = constraintWidget.getX();
|
|
int y = constraintWidget.getY();
|
|
int width = constraintWidget.getWidth() + x;
|
|
int height = constraintWidget.getHeight() + y;
|
|
childAt.layout(x, y, width, height);
|
|
if ((childAt instanceof Placeholder) && (content = ((Placeholder) childAt).getContent()) != null) {
|
|
content.setVisibility(0);
|
|
content.layout(x, y, width, height);
|
|
}
|
|
}
|
|
}
|
|
int size = this.mConstraintHelpers.size();
|
|
if (size > 0) {
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
this.mConstraintHelpers.get(i2).updatePostLayout(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setOptimizationLevel(int level) {
|
|
this.mOptimizationLevel = level;
|
|
this.mLayoutWidget.setOptimizationLevel(level);
|
|
}
|
|
|
|
public int getOptimizationLevel() {
|
|
return this.mLayoutWidget.getOptimizationLevel();
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateLayoutParams(AttributeSet attrs) {
|
|
return new LayoutParams(getContext(), attrs);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: protected */
|
|
@Override // android.view.ViewGroup
|
|
public LayoutParams generateDefaultLayoutParams() {
|
|
return new LayoutParams(-2, -2);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
|
|
return new LayoutParams(p);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup
|
|
protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
|
|
return p instanceof LayoutParams;
|
|
}
|
|
|
|
public View getViewById(int id) {
|
|
return this.mChildrenByIds.get(id);
|
|
}
|
|
|
|
@Override // android.view.ViewGroup, android.view.View
|
|
protected void dispatchDraw(Canvas canvas) {
|
|
Object tag;
|
|
int size;
|
|
ArrayList<ConstraintHelper> arrayList = this.mConstraintHelpers;
|
|
if (arrayList != null && (size = arrayList.size()) > 0) {
|
|
for (int i = 0; i < size; i++) {
|
|
this.mConstraintHelpers.get(i).updatePreDraw(this);
|
|
}
|
|
}
|
|
super.dispatchDraw(canvas);
|
|
if (isInEditMode()) {
|
|
float width = getWidth();
|
|
float height = getHeight();
|
|
int childCount = getChildCount();
|
|
for (int i2 = 0; i2 < childCount; i2++) {
|
|
View childAt = getChildAt(i2);
|
|
if (childAt.getVisibility() != 8 && (tag = childAt.getTag()) != null && (tag instanceof String)) {
|
|
String[] split = ((String) tag).split(",");
|
|
if (split.length == 4) {
|
|
int parseInt = Integer.parseInt(split[0]);
|
|
int parseInt2 = Integer.parseInt(split[1]);
|
|
int parseInt3 = Integer.parseInt(split[2]);
|
|
int i3 = (int) ((parseInt / 1080.0f) * width);
|
|
int i4 = (int) ((parseInt2 / 1920.0f) * height);
|
|
Paint paint = new Paint();
|
|
paint.setColor(SupportMenu.CATEGORY_MASK);
|
|
float f = i3;
|
|
float f2 = i4;
|
|
float f3 = i3 + ((int) ((parseInt3 / 1080.0f) * width));
|
|
canvas.drawLine(f, f2, f3, f2, paint);
|
|
float parseInt4 = i4 + ((int) ((Integer.parseInt(split[3]) / 1920.0f) * height));
|
|
canvas.drawLine(f3, f2, f3, parseInt4, paint);
|
|
canvas.drawLine(f3, parseInt4, f, parseInt4, paint);
|
|
canvas.drawLine(f, parseInt4, f, f2, paint);
|
|
paint.setColor(-16711936);
|
|
canvas.drawLine(f, f2, f3, parseInt4, paint);
|
|
canvas.drawLine(f, parseInt4, f3, f2, paint);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setOnConstraintsChanged(ConstraintsChangedListener constraintsChangedListener) {
|
|
this.mConstraintsChangedListener = constraintsChangedListener;
|
|
ConstraintLayoutStates constraintLayoutStates = this.mConstraintLayoutSpec;
|
|
if (constraintLayoutStates != null) {
|
|
constraintLayoutStates.setOnConstraintsChanged(constraintsChangedListener);
|
|
}
|
|
}
|
|
|
|
public void loadLayoutDescription(int layoutDescription) {
|
|
if (layoutDescription == 0) {
|
|
this.mConstraintLayoutSpec = null;
|
|
return;
|
|
}
|
|
try {
|
|
this.mConstraintLayoutSpec = new ConstraintLayoutStates(getContext(), this, layoutDescription);
|
|
} catch (Resources.NotFoundException unused) {
|
|
this.mConstraintLayoutSpec = null;
|
|
}
|
|
}
|
|
|
|
public static class LayoutParams extends ViewGroup.MarginLayoutParams {
|
|
public static final int BASELINE = 5;
|
|
public static final int BOTTOM = 4;
|
|
public static final int CHAIN_PACKED = 2;
|
|
public static final int CHAIN_SPREAD = 0;
|
|
public static final int CHAIN_SPREAD_INSIDE = 1;
|
|
public static final int CIRCLE = 8;
|
|
public static final int END = 7;
|
|
public static final int GONE_UNSET = Integer.MIN_VALUE;
|
|
public static final int HORIZONTAL = 0;
|
|
public static final int LEFT = 1;
|
|
public static final int MATCH_CONSTRAINT = 0;
|
|
public static final int MATCH_CONSTRAINT_PERCENT = 2;
|
|
public static final int MATCH_CONSTRAINT_SPREAD = 0;
|
|
public static final int MATCH_CONSTRAINT_WRAP = 1;
|
|
public static final int PARENT_ID = 0;
|
|
public static final int RIGHT = 2;
|
|
public static final int START = 6;
|
|
public static final int TOP = 3;
|
|
public static final int UNSET = -1;
|
|
public static final int VERTICAL = 1;
|
|
public static final int WRAP_BEHAVIOR_HORIZONTAL_ONLY = 1;
|
|
public static final int WRAP_BEHAVIOR_INCLUDED = 0;
|
|
public static final int WRAP_BEHAVIOR_SKIPPED = 3;
|
|
public static final int WRAP_BEHAVIOR_VERTICAL_ONLY = 2;
|
|
public int baselineMargin;
|
|
public int baselineToBaseline;
|
|
public int baselineToBottom;
|
|
public int baselineToTop;
|
|
public int bottomToBottom;
|
|
public int bottomToTop;
|
|
public float circleAngle;
|
|
public int circleConstraint;
|
|
public int circleRadius;
|
|
public boolean constrainedHeight;
|
|
public boolean constrainedWidth;
|
|
public String constraintTag;
|
|
public String dimensionRatio;
|
|
int dimensionRatioSide;
|
|
float dimensionRatioValue;
|
|
public int editorAbsoluteX;
|
|
public int editorAbsoluteY;
|
|
public int endToEnd;
|
|
public int endToStart;
|
|
public int goneBaselineMargin;
|
|
public int goneBottomMargin;
|
|
public int goneEndMargin;
|
|
public int goneLeftMargin;
|
|
public int goneRightMargin;
|
|
public int goneStartMargin;
|
|
public int goneTopMargin;
|
|
public int guideBegin;
|
|
public int guideEnd;
|
|
public float guidePercent;
|
|
public boolean guidelineUseRtl;
|
|
boolean heightSet;
|
|
public boolean helped;
|
|
public float horizontalBias;
|
|
public int horizontalChainStyle;
|
|
boolean horizontalDimensionFixed;
|
|
public float horizontalWeight;
|
|
boolean isGuideline;
|
|
boolean isHelper;
|
|
boolean isInPlaceholder;
|
|
boolean isVirtualGroup;
|
|
public int leftToLeft;
|
|
public int leftToRight;
|
|
public int matchConstraintDefaultHeight;
|
|
public int matchConstraintDefaultWidth;
|
|
public int matchConstraintMaxHeight;
|
|
public int matchConstraintMaxWidth;
|
|
public int matchConstraintMinHeight;
|
|
public int matchConstraintMinWidth;
|
|
public float matchConstraintPercentHeight;
|
|
public float matchConstraintPercentWidth;
|
|
boolean needsBaseline;
|
|
public int orientation;
|
|
int resolveGoneLeftMargin;
|
|
int resolveGoneRightMargin;
|
|
int resolvedGuideBegin;
|
|
int resolvedGuideEnd;
|
|
float resolvedGuidePercent;
|
|
float resolvedHorizontalBias;
|
|
int resolvedLeftToLeft;
|
|
int resolvedLeftToRight;
|
|
int resolvedRightToLeft;
|
|
int resolvedRightToRight;
|
|
public int rightToLeft;
|
|
public int rightToRight;
|
|
public int startToEnd;
|
|
public int startToStart;
|
|
public int topToBottom;
|
|
public int topToTop;
|
|
public float verticalBias;
|
|
public int verticalChainStyle;
|
|
boolean verticalDimensionFixed;
|
|
public float verticalWeight;
|
|
ConstraintWidget widget;
|
|
boolean widthSet;
|
|
public int wrapBehaviorInParent;
|
|
|
|
public String getConstraintTag() {
|
|
return this.constraintTag;
|
|
}
|
|
|
|
public ConstraintWidget getConstraintWidget() {
|
|
return this.widget;
|
|
}
|
|
|
|
public void setWidgetDebugName(String text) {
|
|
this.widget.setDebugName(text);
|
|
}
|
|
|
|
public void reset() {
|
|
ConstraintWidget constraintWidget = this.widget;
|
|
if (constraintWidget != null) {
|
|
constraintWidget.reset();
|
|
}
|
|
}
|
|
|
|
public LayoutParams(LayoutParams source) {
|
|
super((ViewGroup.MarginLayoutParams) source);
|
|
this.guideBegin = -1;
|
|
this.guideEnd = -1;
|
|
this.guidePercent = -1.0f;
|
|
this.guidelineUseRtl = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.leftToLeft = -1;
|
|
this.leftToRight = -1;
|
|
this.rightToLeft = -1;
|
|
this.rightToRight = -1;
|
|
this.topToTop = -1;
|
|
this.topToBottom = -1;
|
|
this.bottomToTop = -1;
|
|
this.bottomToBottom = -1;
|
|
this.baselineToBaseline = -1;
|
|
this.baselineToTop = -1;
|
|
this.baselineToBottom = -1;
|
|
this.circleConstraint = -1;
|
|
this.circleRadius = 0;
|
|
this.circleAngle = 0.0f;
|
|
this.startToEnd = -1;
|
|
this.startToStart = -1;
|
|
this.endToStart = -1;
|
|
this.endToEnd = -1;
|
|
this.goneLeftMargin = Integer.MIN_VALUE;
|
|
this.goneTopMargin = Integer.MIN_VALUE;
|
|
this.goneRightMargin = Integer.MIN_VALUE;
|
|
this.goneBottomMargin = Integer.MIN_VALUE;
|
|
this.goneStartMargin = Integer.MIN_VALUE;
|
|
this.goneEndMargin = Integer.MIN_VALUE;
|
|
this.goneBaselineMargin = Integer.MIN_VALUE;
|
|
this.baselineMargin = 0;
|
|
this.widthSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.heightSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.horizontalBias = 0.5f;
|
|
this.verticalBias = 0.5f;
|
|
this.dimensionRatio = null;
|
|
this.dimensionRatioValue = 0.0f;
|
|
this.dimensionRatioSide = 1;
|
|
this.horizontalWeight = -1.0f;
|
|
this.verticalWeight = -1.0f;
|
|
this.horizontalChainStyle = 0;
|
|
this.verticalChainStyle = 0;
|
|
this.matchConstraintDefaultWidth = 0;
|
|
this.matchConstraintDefaultHeight = 0;
|
|
this.matchConstraintMinWidth = 0;
|
|
this.matchConstraintMinHeight = 0;
|
|
this.matchConstraintMaxWidth = 0;
|
|
this.matchConstraintMaxHeight = 0;
|
|
this.matchConstraintPercentWidth = 1.0f;
|
|
this.matchConstraintPercentHeight = 1.0f;
|
|
this.editorAbsoluteX = -1;
|
|
this.editorAbsoluteY = -1;
|
|
this.orientation = -1;
|
|
this.constrainedWidth = false;
|
|
this.constrainedHeight = false;
|
|
this.constraintTag = null;
|
|
this.wrapBehaviorInParent = 0;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.needsBaseline = false;
|
|
this.isGuideline = false;
|
|
this.isHelper = false;
|
|
this.isInPlaceholder = false;
|
|
this.isVirtualGroup = false;
|
|
this.resolvedLeftToLeft = -1;
|
|
this.resolvedLeftToRight = -1;
|
|
this.resolvedRightToLeft = -1;
|
|
this.resolvedRightToRight = -1;
|
|
this.resolveGoneLeftMargin = Integer.MIN_VALUE;
|
|
this.resolveGoneRightMargin = Integer.MIN_VALUE;
|
|
this.resolvedHorizontalBias = 0.5f;
|
|
this.widget = new ConstraintWidget();
|
|
this.helped = false;
|
|
this.guideBegin = source.guideBegin;
|
|
this.guideEnd = source.guideEnd;
|
|
this.guidePercent = source.guidePercent;
|
|
this.guidelineUseRtl = source.guidelineUseRtl;
|
|
this.leftToLeft = source.leftToLeft;
|
|
this.leftToRight = source.leftToRight;
|
|
this.rightToLeft = source.rightToLeft;
|
|
this.rightToRight = source.rightToRight;
|
|
this.topToTop = source.topToTop;
|
|
this.topToBottom = source.topToBottom;
|
|
this.bottomToTop = source.bottomToTop;
|
|
this.bottomToBottom = source.bottomToBottom;
|
|
this.baselineToBaseline = source.baselineToBaseline;
|
|
this.baselineToTop = source.baselineToTop;
|
|
this.baselineToBottom = source.baselineToBottom;
|
|
this.circleConstraint = source.circleConstraint;
|
|
this.circleRadius = source.circleRadius;
|
|
this.circleAngle = source.circleAngle;
|
|
this.startToEnd = source.startToEnd;
|
|
this.startToStart = source.startToStart;
|
|
this.endToStart = source.endToStart;
|
|
this.endToEnd = source.endToEnd;
|
|
this.goneLeftMargin = source.goneLeftMargin;
|
|
this.goneTopMargin = source.goneTopMargin;
|
|
this.goneRightMargin = source.goneRightMargin;
|
|
this.goneBottomMargin = source.goneBottomMargin;
|
|
this.goneStartMargin = source.goneStartMargin;
|
|
this.goneEndMargin = source.goneEndMargin;
|
|
this.goneBaselineMargin = source.goneBaselineMargin;
|
|
this.baselineMargin = source.baselineMargin;
|
|
this.horizontalBias = source.horizontalBias;
|
|
this.verticalBias = source.verticalBias;
|
|
this.dimensionRatio = source.dimensionRatio;
|
|
this.dimensionRatioValue = source.dimensionRatioValue;
|
|
this.dimensionRatioSide = source.dimensionRatioSide;
|
|
this.horizontalWeight = source.horizontalWeight;
|
|
this.verticalWeight = source.verticalWeight;
|
|
this.horizontalChainStyle = source.horizontalChainStyle;
|
|
this.verticalChainStyle = source.verticalChainStyle;
|
|
this.constrainedWidth = source.constrainedWidth;
|
|
this.constrainedHeight = source.constrainedHeight;
|
|
this.matchConstraintDefaultWidth = source.matchConstraintDefaultWidth;
|
|
this.matchConstraintDefaultHeight = source.matchConstraintDefaultHeight;
|
|
this.matchConstraintMinWidth = source.matchConstraintMinWidth;
|
|
this.matchConstraintMaxWidth = source.matchConstraintMaxWidth;
|
|
this.matchConstraintMinHeight = source.matchConstraintMinHeight;
|
|
this.matchConstraintMaxHeight = source.matchConstraintMaxHeight;
|
|
this.matchConstraintPercentWidth = source.matchConstraintPercentWidth;
|
|
this.matchConstraintPercentHeight = source.matchConstraintPercentHeight;
|
|
this.editorAbsoluteX = source.editorAbsoluteX;
|
|
this.editorAbsoluteY = source.editorAbsoluteY;
|
|
this.orientation = source.orientation;
|
|
this.horizontalDimensionFixed = source.horizontalDimensionFixed;
|
|
this.verticalDimensionFixed = source.verticalDimensionFixed;
|
|
this.needsBaseline = source.needsBaseline;
|
|
this.isGuideline = source.isGuideline;
|
|
this.resolvedLeftToLeft = source.resolvedLeftToLeft;
|
|
this.resolvedLeftToRight = source.resolvedLeftToRight;
|
|
this.resolvedRightToLeft = source.resolvedRightToLeft;
|
|
this.resolvedRightToRight = source.resolvedRightToRight;
|
|
this.resolveGoneLeftMargin = source.resolveGoneLeftMargin;
|
|
this.resolveGoneRightMargin = source.resolveGoneRightMargin;
|
|
this.resolvedHorizontalBias = source.resolvedHorizontalBias;
|
|
this.constraintTag = source.constraintTag;
|
|
this.wrapBehaviorInParent = source.wrapBehaviorInParent;
|
|
this.widget = source.widget;
|
|
this.widthSet = source.widthSet;
|
|
this.heightSet = source.heightSet;
|
|
}
|
|
|
|
private static class Table {
|
|
public static final int ANDROID_ORIENTATION = 1;
|
|
public static final int GUIDELINE_USE_RTL = 67;
|
|
public static final int LAYOUT_CONSTRAINED_HEIGHT = 28;
|
|
public static final int LAYOUT_CONSTRAINED_WIDTH = 27;
|
|
public static final int LAYOUT_CONSTRAINT_BASELINE_CREATOR = 43;
|
|
public static final int LAYOUT_CONSTRAINT_BASELINE_TO_BASELINE_OF = 16;
|
|
public static final int LAYOUT_CONSTRAINT_BASELINE_TO_BOTTOM_OF = 53;
|
|
public static final int LAYOUT_CONSTRAINT_BASELINE_TO_TOP_OF = 52;
|
|
public static final int LAYOUT_CONSTRAINT_BOTTOM_CREATOR = 42;
|
|
public static final int LAYOUT_CONSTRAINT_BOTTOM_TO_BOTTOM_OF = 15;
|
|
public static final int LAYOUT_CONSTRAINT_BOTTOM_TO_TOP_OF = 14;
|
|
public static final int LAYOUT_CONSTRAINT_CIRCLE = 2;
|
|
public static final int LAYOUT_CONSTRAINT_CIRCLE_ANGLE = 4;
|
|
public static final int LAYOUT_CONSTRAINT_CIRCLE_RADIUS = 3;
|
|
public static final int LAYOUT_CONSTRAINT_DIMENSION_RATIO = 44;
|
|
public static final int LAYOUT_CONSTRAINT_END_TO_END_OF = 20;
|
|
public static final int LAYOUT_CONSTRAINT_END_TO_START_OF = 19;
|
|
public static final int LAYOUT_CONSTRAINT_GUIDE_BEGIN = 5;
|
|
public static final int LAYOUT_CONSTRAINT_GUIDE_END = 6;
|
|
public static final int LAYOUT_CONSTRAINT_GUIDE_PERCENT = 7;
|
|
public static final int LAYOUT_CONSTRAINT_HEIGHT = 65;
|
|
public static final int LAYOUT_CONSTRAINT_HEIGHT_DEFAULT = 32;
|
|
public static final int LAYOUT_CONSTRAINT_HEIGHT_MAX = 37;
|
|
public static final int LAYOUT_CONSTRAINT_HEIGHT_MIN = 36;
|
|
public static final int LAYOUT_CONSTRAINT_HEIGHT_PERCENT = 38;
|
|
public static final int LAYOUT_CONSTRAINT_HORIZONTAL_BIAS = 29;
|
|
public static final int LAYOUT_CONSTRAINT_HORIZONTAL_CHAINSTYLE = 47;
|
|
public static final int LAYOUT_CONSTRAINT_HORIZONTAL_WEIGHT = 45;
|
|
public static final int LAYOUT_CONSTRAINT_LEFT_CREATOR = 39;
|
|
public static final int LAYOUT_CONSTRAINT_LEFT_TO_LEFT_OF = 8;
|
|
public static final int LAYOUT_CONSTRAINT_LEFT_TO_RIGHT_OF = 9;
|
|
public static final int LAYOUT_CONSTRAINT_RIGHT_CREATOR = 41;
|
|
public static final int LAYOUT_CONSTRAINT_RIGHT_TO_LEFT_OF = 10;
|
|
public static final int LAYOUT_CONSTRAINT_RIGHT_TO_RIGHT_OF = 11;
|
|
public static final int LAYOUT_CONSTRAINT_START_TO_END_OF = 17;
|
|
public static final int LAYOUT_CONSTRAINT_START_TO_START_OF = 18;
|
|
public static final int LAYOUT_CONSTRAINT_TAG = 51;
|
|
public static final int LAYOUT_CONSTRAINT_TOP_CREATOR = 40;
|
|
public static final int LAYOUT_CONSTRAINT_TOP_TO_BOTTOM_OF = 13;
|
|
public static final int LAYOUT_CONSTRAINT_TOP_TO_TOP_OF = 12;
|
|
public static final int LAYOUT_CONSTRAINT_VERTICAL_BIAS = 30;
|
|
public static final int LAYOUT_CONSTRAINT_VERTICAL_CHAINSTYLE = 48;
|
|
public static final int LAYOUT_CONSTRAINT_VERTICAL_WEIGHT = 46;
|
|
public static final int LAYOUT_CONSTRAINT_WIDTH = 64;
|
|
public static final int LAYOUT_CONSTRAINT_WIDTH_DEFAULT = 31;
|
|
public static final int LAYOUT_CONSTRAINT_WIDTH_MAX = 34;
|
|
public static final int LAYOUT_CONSTRAINT_WIDTH_MIN = 33;
|
|
public static final int LAYOUT_CONSTRAINT_WIDTH_PERCENT = 35;
|
|
public static final int LAYOUT_EDITOR_ABSOLUTEX = 49;
|
|
public static final int LAYOUT_EDITOR_ABSOLUTEY = 50;
|
|
public static final int LAYOUT_GONE_MARGIN_BASELINE = 55;
|
|
public static final int LAYOUT_GONE_MARGIN_BOTTOM = 24;
|
|
public static final int LAYOUT_GONE_MARGIN_END = 26;
|
|
public static final int LAYOUT_GONE_MARGIN_LEFT = 21;
|
|
public static final int LAYOUT_GONE_MARGIN_RIGHT = 23;
|
|
public static final int LAYOUT_GONE_MARGIN_START = 25;
|
|
public static final int LAYOUT_GONE_MARGIN_TOP = 22;
|
|
public static final int LAYOUT_MARGIN_BASELINE = 54;
|
|
public static final int LAYOUT_WRAP_BEHAVIOR_IN_PARENT = 66;
|
|
public static final int UNUSED = 0;
|
|
public static final SparseIntArray map;
|
|
|
|
private Table() {
|
|
}
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
map = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintWidth, 64);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHeight, 65);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintLeft_toLeftOf, 8);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintLeft_toRightOf, 9);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintRight_toLeftOf, 10);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintRight_toRightOf, 11);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintTop_toTopOf, 12);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintTop_toBottomOf, 13);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBottom_toTopOf, 14);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBottom_toBottomOf, 15);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBaseline_toBaselineOf, 16);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBaseline_toTopOf, 52);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBaseline_toBottomOf, 53);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintCircle, 2);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintCircleRadius, 3);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintCircleAngle, 4);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_editor_absoluteX, 49);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_editor_absoluteY, 50);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintGuide_begin, 5);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintGuide_end, 6);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintGuide_percent, 7);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_guidelineUseRtl, 67);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_android_orientation, 1);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintStart_toEndOf, 17);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintStart_toStartOf, 18);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintEnd_toStartOf, 19);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintEnd_toEndOf, 20);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginLeft, 21);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginTop, 22);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginRight, 23);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginBottom, 24);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginStart, 25);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginEnd, 26);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_goneMarginBaseline, 55);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_marginBaseline, 54);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHorizontal_bias, 29);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintVertical_bias, 30);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintDimensionRatio, 44);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHorizontal_weight, 45);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintVertical_weight, 46);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHorizontal_chainStyle, 47);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintVertical_chainStyle, 48);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constrainedWidth, 27);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constrainedHeight, 28);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintWidth_default, 31);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHeight_default, 32);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintWidth_min, 33);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintWidth_max, 34);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintWidth_percent, 35);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHeight_min, 36);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHeight_max, 37);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintHeight_percent, 38);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintLeft_creator, 39);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintTop_creator, 40);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintRight_creator, 41);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBottom_creator, 42);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintBaseline_creator, 43);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_constraintTag, 51);
|
|
sparseIntArray.append(R.styleable.ConstraintLayout_Layout_layout_wrapBehaviorInParent, 66);
|
|
}
|
|
}
|
|
|
|
public LayoutParams(Context c, AttributeSet attrs) {
|
|
super(c, attrs);
|
|
this.guideBegin = -1;
|
|
this.guideEnd = -1;
|
|
this.guidePercent = -1.0f;
|
|
this.guidelineUseRtl = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.leftToLeft = -1;
|
|
this.leftToRight = -1;
|
|
this.rightToLeft = -1;
|
|
this.rightToRight = -1;
|
|
this.topToTop = -1;
|
|
this.topToBottom = -1;
|
|
this.bottomToTop = -1;
|
|
this.bottomToBottom = -1;
|
|
this.baselineToBaseline = -1;
|
|
this.baselineToTop = -1;
|
|
this.baselineToBottom = -1;
|
|
this.circleConstraint = -1;
|
|
this.circleRadius = 0;
|
|
this.circleAngle = 0.0f;
|
|
this.startToEnd = -1;
|
|
this.startToStart = -1;
|
|
this.endToStart = -1;
|
|
this.endToEnd = -1;
|
|
this.goneLeftMargin = Integer.MIN_VALUE;
|
|
this.goneTopMargin = Integer.MIN_VALUE;
|
|
this.goneRightMargin = Integer.MIN_VALUE;
|
|
this.goneBottomMargin = Integer.MIN_VALUE;
|
|
this.goneStartMargin = Integer.MIN_VALUE;
|
|
this.goneEndMargin = Integer.MIN_VALUE;
|
|
this.goneBaselineMargin = Integer.MIN_VALUE;
|
|
this.baselineMargin = 0;
|
|
this.widthSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.heightSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.horizontalBias = 0.5f;
|
|
this.verticalBias = 0.5f;
|
|
this.dimensionRatio = null;
|
|
this.dimensionRatioValue = 0.0f;
|
|
this.dimensionRatioSide = 1;
|
|
this.horizontalWeight = -1.0f;
|
|
this.verticalWeight = -1.0f;
|
|
this.horizontalChainStyle = 0;
|
|
this.verticalChainStyle = 0;
|
|
this.matchConstraintDefaultWidth = 0;
|
|
this.matchConstraintDefaultHeight = 0;
|
|
this.matchConstraintMinWidth = 0;
|
|
this.matchConstraintMinHeight = 0;
|
|
this.matchConstraintMaxWidth = 0;
|
|
this.matchConstraintMaxHeight = 0;
|
|
this.matchConstraintPercentWidth = 1.0f;
|
|
this.matchConstraintPercentHeight = 1.0f;
|
|
this.editorAbsoluteX = -1;
|
|
this.editorAbsoluteY = -1;
|
|
this.orientation = -1;
|
|
this.constrainedWidth = false;
|
|
this.constrainedHeight = false;
|
|
this.constraintTag = null;
|
|
this.wrapBehaviorInParent = 0;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.needsBaseline = false;
|
|
this.isGuideline = false;
|
|
this.isHelper = false;
|
|
this.isInPlaceholder = false;
|
|
this.isVirtualGroup = false;
|
|
this.resolvedLeftToLeft = -1;
|
|
this.resolvedLeftToRight = -1;
|
|
this.resolvedRightToLeft = -1;
|
|
this.resolvedRightToRight = -1;
|
|
this.resolveGoneLeftMargin = Integer.MIN_VALUE;
|
|
this.resolveGoneRightMargin = Integer.MIN_VALUE;
|
|
this.resolvedHorizontalBias = 0.5f;
|
|
this.widget = new ConstraintWidget();
|
|
this.helped = false;
|
|
TypedArray obtainStyledAttributes = c.obtainStyledAttributes(attrs, R.styleable.ConstraintLayout_Layout);
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
int i2 = Table.map.get(index);
|
|
switch (i2) {
|
|
case 1:
|
|
this.orientation = obtainStyledAttributes.getInt(index, this.orientation);
|
|
break;
|
|
case 2:
|
|
int resourceId = obtainStyledAttributes.getResourceId(index, this.circleConstraint);
|
|
this.circleConstraint = resourceId;
|
|
if (resourceId == -1) {
|
|
this.circleConstraint = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 3:
|
|
this.circleRadius = obtainStyledAttributes.getDimensionPixelSize(index, this.circleRadius);
|
|
break;
|
|
case 4:
|
|
float f = obtainStyledAttributes.getFloat(index, this.circleAngle) % 360.0f;
|
|
this.circleAngle = f;
|
|
if (f < 0.0f) {
|
|
this.circleAngle = (360.0f - f) % 360.0f;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 5:
|
|
this.guideBegin = obtainStyledAttributes.getDimensionPixelOffset(index, this.guideBegin);
|
|
break;
|
|
case 6:
|
|
this.guideEnd = obtainStyledAttributes.getDimensionPixelOffset(index, this.guideEnd);
|
|
break;
|
|
case 7:
|
|
this.guidePercent = obtainStyledAttributes.getFloat(index, this.guidePercent);
|
|
break;
|
|
case 8:
|
|
int resourceId2 = obtainStyledAttributes.getResourceId(index, this.leftToLeft);
|
|
this.leftToLeft = resourceId2;
|
|
if (resourceId2 == -1) {
|
|
this.leftToLeft = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 9:
|
|
int resourceId3 = obtainStyledAttributes.getResourceId(index, this.leftToRight);
|
|
this.leftToRight = resourceId3;
|
|
if (resourceId3 == -1) {
|
|
this.leftToRight = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 10:
|
|
int resourceId4 = obtainStyledAttributes.getResourceId(index, this.rightToLeft);
|
|
this.rightToLeft = resourceId4;
|
|
if (resourceId4 == -1) {
|
|
this.rightToLeft = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 11:
|
|
int resourceId5 = obtainStyledAttributes.getResourceId(index, this.rightToRight);
|
|
this.rightToRight = resourceId5;
|
|
if (resourceId5 == -1) {
|
|
this.rightToRight = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 12:
|
|
int resourceId6 = obtainStyledAttributes.getResourceId(index, this.topToTop);
|
|
this.topToTop = resourceId6;
|
|
if (resourceId6 == -1) {
|
|
this.topToTop = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 13:
|
|
int resourceId7 = obtainStyledAttributes.getResourceId(index, this.topToBottom);
|
|
this.topToBottom = resourceId7;
|
|
if (resourceId7 == -1) {
|
|
this.topToBottom = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 14:
|
|
int resourceId8 = obtainStyledAttributes.getResourceId(index, this.bottomToTop);
|
|
this.bottomToTop = resourceId8;
|
|
if (resourceId8 == -1) {
|
|
this.bottomToTop = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 15:
|
|
int resourceId9 = obtainStyledAttributes.getResourceId(index, this.bottomToBottom);
|
|
this.bottomToBottom = resourceId9;
|
|
if (resourceId9 == -1) {
|
|
this.bottomToBottom = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 16:
|
|
int resourceId10 = obtainStyledAttributes.getResourceId(index, this.baselineToBaseline);
|
|
this.baselineToBaseline = resourceId10;
|
|
if (resourceId10 == -1) {
|
|
this.baselineToBaseline = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 17:
|
|
int resourceId11 = obtainStyledAttributes.getResourceId(index, this.startToEnd);
|
|
this.startToEnd = resourceId11;
|
|
if (resourceId11 == -1) {
|
|
this.startToEnd = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 18:
|
|
int resourceId12 = obtainStyledAttributes.getResourceId(index, this.startToStart);
|
|
this.startToStart = resourceId12;
|
|
if (resourceId12 == -1) {
|
|
this.startToStart = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 19:
|
|
int resourceId13 = obtainStyledAttributes.getResourceId(index, this.endToStart);
|
|
this.endToStart = resourceId13;
|
|
if (resourceId13 == -1) {
|
|
this.endToStart = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 20:
|
|
int resourceId14 = obtainStyledAttributes.getResourceId(index, this.endToEnd);
|
|
this.endToEnd = resourceId14;
|
|
if (resourceId14 == -1) {
|
|
this.endToEnd = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 21:
|
|
this.goneLeftMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneLeftMargin);
|
|
break;
|
|
case 22:
|
|
this.goneTopMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneTopMargin);
|
|
break;
|
|
case 23:
|
|
this.goneRightMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneRightMargin);
|
|
break;
|
|
case 24:
|
|
this.goneBottomMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneBottomMargin);
|
|
break;
|
|
case 25:
|
|
this.goneStartMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneStartMargin);
|
|
break;
|
|
case 26:
|
|
this.goneEndMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneEndMargin);
|
|
break;
|
|
case 27:
|
|
this.constrainedWidth = obtainStyledAttributes.getBoolean(index, this.constrainedWidth);
|
|
break;
|
|
case 28:
|
|
this.constrainedHeight = obtainStyledAttributes.getBoolean(index, this.constrainedHeight);
|
|
break;
|
|
case 29:
|
|
this.horizontalBias = obtainStyledAttributes.getFloat(index, this.horizontalBias);
|
|
break;
|
|
case 30:
|
|
this.verticalBias = obtainStyledAttributes.getFloat(index, this.verticalBias);
|
|
break;
|
|
case 31:
|
|
int i3 = obtainStyledAttributes.getInt(index, 0);
|
|
this.matchConstraintDefaultWidth = i3;
|
|
if (i3 == 1) {
|
|
Log.e(ConstraintLayout.TAG, "layout_constraintWidth_default=\"wrap\" is deprecated.\nUse layout_width=\"WRAP_CONTENT\" and layout_constrainedWidth=\"true\" instead.");
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 32:
|
|
int i4 = obtainStyledAttributes.getInt(index, 0);
|
|
this.matchConstraintDefaultHeight = i4;
|
|
if (i4 == 1) {
|
|
Log.e(ConstraintLayout.TAG, "layout_constraintHeight_default=\"wrap\" is deprecated.\nUse layout_height=\"WRAP_CONTENT\" and layout_constrainedHeight=\"true\" instead.");
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 33:
|
|
try {
|
|
this.matchConstraintMinWidth = obtainStyledAttributes.getDimensionPixelSize(index, this.matchConstraintMinWidth);
|
|
break;
|
|
} catch (Exception unused) {
|
|
if (obtainStyledAttributes.getInt(index, this.matchConstraintMinWidth) == -2) {
|
|
this.matchConstraintMinWidth = -2;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
case 34:
|
|
try {
|
|
this.matchConstraintMaxWidth = obtainStyledAttributes.getDimensionPixelSize(index, this.matchConstraintMaxWidth);
|
|
break;
|
|
} catch (Exception unused2) {
|
|
if (obtainStyledAttributes.getInt(index, this.matchConstraintMaxWidth) == -2) {
|
|
this.matchConstraintMaxWidth = -2;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
case 35:
|
|
this.matchConstraintPercentWidth = Math.max(0.0f, obtainStyledAttributes.getFloat(index, this.matchConstraintPercentWidth));
|
|
this.matchConstraintDefaultWidth = 2;
|
|
break;
|
|
case 36:
|
|
try {
|
|
this.matchConstraintMinHeight = obtainStyledAttributes.getDimensionPixelSize(index, this.matchConstraintMinHeight);
|
|
break;
|
|
} catch (Exception unused3) {
|
|
if (obtainStyledAttributes.getInt(index, this.matchConstraintMinHeight) == -2) {
|
|
this.matchConstraintMinHeight = -2;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
case 37:
|
|
try {
|
|
this.matchConstraintMaxHeight = obtainStyledAttributes.getDimensionPixelSize(index, this.matchConstraintMaxHeight);
|
|
break;
|
|
} catch (Exception unused4) {
|
|
if (obtainStyledAttributes.getInt(index, this.matchConstraintMaxHeight) == -2) {
|
|
this.matchConstraintMaxHeight = -2;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
case 38:
|
|
this.matchConstraintPercentHeight = Math.max(0.0f, obtainStyledAttributes.getFloat(index, this.matchConstraintPercentHeight));
|
|
this.matchConstraintDefaultHeight = 2;
|
|
break;
|
|
default:
|
|
switch (i2) {
|
|
case 44:
|
|
ConstraintSet.parseDimensionRatioString(this, obtainStyledAttributes.getString(index));
|
|
break;
|
|
case 45:
|
|
this.horizontalWeight = obtainStyledAttributes.getFloat(index, this.horizontalWeight);
|
|
break;
|
|
case 46:
|
|
this.verticalWeight = obtainStyledAttributes.getFloat(index, this.verticalWeight);
|
|
break;
|
|
case 47:
|
|
this.horizontalChainStyle = obtainStyledAttributes.getInt(index, 0);
|
|
break;
|
|
case 48:
|
|
this.verticalChainStyle = obtainStyledAttributes.getInt(index, 0);
|
|
break;
|
|
case 49:
|
|
this.editorAbsoluteX = obtainStyledAttributes.getDimensionPixelOffset(index, this.editorAbsoluteX);
|
|
break;
|
|
case 50:
|
|
this.editorAbsoluteY = obtainStyledAttributes.getDimensionPixelOffset(index, this.editorAbsoluteY);
|
|
break;
|
|
case 51:
|
|
this.constraintTag = obtainStyledAttributes.getString(index);
|
|
break;
|
|
case 52:
|
|
int resourceId15 = obtainStyledAttributes.getResourceId(index, this.baselineToTop);
|
|
this.baselineToTop = resourceId15;
|
|
if (resourceId15 == -1) {
|
|
this.baselineToTop = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 53:
|
|
int resourceId16 = obtainStyledAttributes.getResourceId(index, this.baselineToBottom);
|
|
this.baselineToBottom = resourceId16;
|
|
if (resourceId16 == -1) {
|
|
this.baselineToBottom = obtainStyledAttributes.getInt(index, -1);
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
case 54:
|
|
this.baselineMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.baselineMargin);
|
|
break;
|
|
case 55:
|
|
this.goneBaselineMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneBaselineMargin);
|
|
break;
|
|
default:
|
|
switch (i2) {
|
|
case 64:
|
|
ConstraintSet.parseDimensionConstraints(this, obtainStyledAttributes, index, 0);
|
|
this.widthSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
break;
|
|
case 65:
|
|
ConstraintSet.parseDimensionConstraints(this, obtainStyledAttributes, index, 1);
|
|
this.heightSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
break;
|
|
case 66:
|
|
this.wrapBehaviorInParent = obtainStyledAttributes.getInt(index, this.wrapBehaviorInParent);
|
|
break;
|
|
case 67:
|
|
this.guidelineUseRtl = obtainStyledAttributes.getBoolean(index, this.guidelineUseRtl);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
validate();
|
|
}
|
|
|
|
public void validate() {
|
|
this.isGuideline = false;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
if (this.width == -2 && this.constrainedWidth) {
|
|
this.horizontalDimensionFixed = false;
|
|
if (this.matchConstraintDefaultWidth == 0) {
|
|
this.matchConstraintDefaultWidth = 1;
|
|
}
|
|
}
|
|
if (this.height == -2 && this.constrainedHeight) {
|
|
this.verticalDimensionFixed = false;
|
|
if (this.matchConstraintDefaultHeight == 0) {
|
|
this.matchConstraintDefaultHeight = 1;
|
|
}
|
|
}
|
|
if (this.width == 0 || this.width == -1) {
|
|
this.horizontalDimensionFixed = false;
|
|
if (this.width == 0 && this.matchConstraintDefaultWidth == 1) {
|
|
this.width = -2;
|
|
this.constrainedWidth = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
}
|
|
if (this.height == 0 || this.height == -1) {
|
|
this.verticalDimensionFixed = false;
|
|
if (this.height == 0 && this.matchConstraintDefaultHeight == 1) {
|
|
this.height = -2;
|
|
this.constrainedHeight = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
}
|
|
}
|
|
if (this.guidePercent == -1.0f && this.guideBegin == -1 && this.guideEnd == -1) {
|
|
return;
|
|
}
|
|
this.isGuideline = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
if (!(this.widget instanceof androidx.constraintlayout.core.widgets.Guideline)) {
|
|
this.widget = new androidx.constraintlayout.core.widgets.Guideline();
|
|
}
|
|
((androidx.constraintlayout.core.widgets.Guideline) this.widget).setOrientation(this.orientation);
|
|
}
|
|
|
|
public LayoutParams(int width, int height) {
|
|
super(width, height);
|
|
this.guideBegin = -1;
|
|
this.guideEnd = -1;
|
|
this.guidePercent = -1.0f;
|
|
this.guidelineUseRtl = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.leftToLeft = -1;
|
|
this.leftToRight = -1;
|
|
this.rightToLeft = -1;
|
|
this.rightToRight = -1;
|
|
this.topToTop = -1;
|
|
this.topToBottom = -1;
|
|
this.bottomToTop = -1;
|
|
this.bottomToBottom = -1;
|
|
this.baselineToBaseline = -1;
|
|
this.baselineToTop = -1;
|
|
this.baselineToBottom = -1;
|
|
this.circleConstraint = -1;
|
|
this.circleRadius = 0;
|
|
this.circleAngle = 0.0f;
|
|
this.startToEnd = -1;
|
|
this.startToStart = -1;
|
|
this.endToStart = -1;
|
|
this.endToEnd = -1;
|
|
this.goneLeftMargin = Integer.MIN_VALUE;
|
|
this.goneTopMargin = Integer.MIN_VALUE;
|
|
this.goneRightMargin = Integer.MIN_VALUE;
|
|
this.goneBottomMargin = Integer.MIN_VALUE;
|
|
this.goneStartMargin = Integer.MIN_VALUE;
|
|
this.goneEndMargin = Integer.MIN_VALUE;
|
|
this.goneBaselineMargin = Integer.MIN_VALUE;
|
|
this.baselineMargin = 0;
|
|
this.widthSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.heightSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.horizontalBias = 0.5f;
|
|
this.verticalBias = 0.5f;
|
|
this.dimensionRatio = null;
|
|
this.dimensionRatioValue = 0.0f;
|
|
this.dimensionRatioSide = 1;
|
|
this.horizontalWeight = -1.0f;
|
|
this.verticalWeight = -1.0f;
|
|
this.horizontalChainStyle = 0;
|
|
this.verticalChainStyle = 0;
|
|
this.matchConstraintDefaultWidth = 0;
|
|
this.matchConstraintDefaultHeight = 0;
|
|
this.matchConstraintMinWidth = 0;
|
|
this.matchConstraintMinHeight = 0;
|
|
this.matchConstraintMaxWidth = 0;
|
|
this.matchConstraintMaxHeight = 0;
|
|
this.matchConstraintPercentWidth = 1.0f;
|
|
this.matchConstraintPercentHeight = 1.0f;
|
|
this.editorAbsoluteX = -1;
|
|
this.editorAbsoluteY = -1;
|
|
this.orientation = -1;
|
|
this.constrainedWidth = false;
|
|
this.constrainedHeight = false;
|
|
this.constraintTag = null;
|
|
this.wrapBehaviorInParent = 0;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.needsBaseline = false;
|
|
this.isGuideline = false;
|
|
this.isHelper = false;
|
|
this.isInPlaceholder = false;
|
|
this.isVirtualGroup = false;
|
|
this.resolvedLeftToLeft = -1;
|
|
this.resolvedLeftToRight = -1;
|
|
this.resolvedRightToLeft = -1;
|
|
this.resolvedRightToRight = -1;
|
|
this.resolveGoneLeftMargin = Integer.MIN_VALUE;
|
|
this.resolveGoneRightMargin = Integer.MIN_VALUE;
|
|
this.resolvedHorizontalBias = 0.5f;
|
|
this.widget = new ConstraintWidget();
|
|
this.helped = false;
|
|
}
|
|
|
|
public LayoutParams(ViewGroup.LayoutParams source) {
|
|
super(source);
|
|
this.guideBegin = -1;
|
|
this.guideEnd = -1;
|
|
this.guidePercent = -1.0f;
|
|
this.guidelineUseRtl = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.leftToLeft = -1;
|
|
this.leftToRight = -1;
|
|
this.rightToLeft = -1;
|
|
this.rightToRight = -1;
|
|
this.topToTop = -1;
|
|
this.topToBottom = -1;
|
|
this.bottomToTop = -1;
|
|
this.bottomToBottom = -1;
|
|
this.baselineToBaseline = -1;
|
|
this.baselineToTop = -1;
|
|
this.baselineToBottom = -1;
|
|
this.circleConstraint = -1;
|
|
this.circleRadius = 0;
|
|
this.circleAngle = 0.0f;
|
|
this.startToEnd = -1;
|
|
this.startToStart = -1;
|
|
this.endToStart = -1;
|
|
this.endToEnd = -1;
|
|
this.goneLeftMargin = Integer.MIN_VALUE;
|
|
this.goneTopMargin = Integer.MIN_VALUE;
|
|
this.goneRightMargin = Integer.MIN_VALUE;
|
|
this.goneBottomMargin = Integer.MIN_VALUE;
|
|
this.goneStartMargin = Integer.MIN_VALUE;
|
|
this.goneEndMargin = Integer.MIN_VALUE;
|
|
this.goneBaselineMargin = Integer.MIN_VALUE;
|
|
this.baselineMargin = 0;
|
|
this.widthSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.heightSet = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.horizontalBias = 0.5f;
|
|
this.verticalBias = 0.5f;
|
|
this.dimensionRatio = null;
|
|
this.dimensionRatioValue = 0.0f;
|
|
this.dimensionRatioSide = 1;
|
|
this.horizontalWeight = -1.0f;
|
|
this.verticalWeight = -1.0f;
|
|
this.horizontalChainStyle = 0;
|
|
this.verticalChainStyle = 0;
|
|
this.matchConstraintDefaultWidth = 0;
|
|
this.matchConstraintDefaultHeight = 0;
|
|
this.matchConstraintMinWidth = 0;
|
|
this.matchConstraintMinHeight = 0;
|
|
this.matchConstraintMaxWidth = 0;
|
|
this.matchConstraintMaxHeight = 0;
|
|
this.matchConstraintPercentWidth = 1.0f;
|
|
this.matchConstraintPercentHeight = 1.0f;
|
|
this.editorAbsoluteX = -1;
|
|
this.editorAbsoluteY = -1;
|
|
this.orientation = -1;
|
|
this.constrainedWidth = false;
|
|
this.constrainedHeight = false;
|
|
this.constraintTag = null;
|
|
this.wrapBehaviorInParent = 0;
|
|
this.horizontalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.verticalDimensionFixed = ConstraintLayout.USE_CONSTRAINTS_HELPER;
|
|
this.needsBaseline = false;
|
|
this.isGuideline = false;
|
|
this.isHelper = false;
|
|
this.isInPlaceholder = false;
|
|
this.isVirtualGroup = false;
|
|
this.resolvedLeftToLeft = -1;
|
|
this.resolvedLeftToRight = -1;
|
|
this.resolvedRightToLeft = -1;
|
|
this.resolvedRightToRight = -1;
|
|
this.resolveGoneLeftMargin = Integer.MIN_VALUE;
|
|
this.resolveGoneRightMargin = Integer.MIN_VALUE;
|
|
this.resolvedHorizontalBias = 0.5f;
|
|
this.widget = new ConstraintWidget();
|
|
this.helped = false;
|
|
}
|
|
|
|
/* JADX WARN: Removed duplicated region for block: B:12:0x004a */
|
|
/* JADX WARN: Removed duplicated region for block: B:15:0x0051 */
|
|
/* JADX WARN: Removed duplicated region for block: B:18:0x0058 */
|
|
/* JADX WARN: Removed duplicated region for block: B:21:0x005e */
|
|
/* JADX WARN: Removed duplicated region for block: B:24:0x0064 */
|
|
/* JADX WARN: Removed duplicated region for block: B:33:0x007a */
|
|
/* JADX WARN: Removed duplicated region for block: B:34:0x0082 */
|
|
@Override // android.view.ViewGroup.MarginLayoutParams, android.view.ViewGroup.LayoutParams
|
|
/*
|
|
Code decompiled incorrectly, please refer to instructions dump.
|
|
To view partially-correct add '--show-bad-code' argument
|
|
*/
|
|
public void resolveLayoutDirection(int r11) {
|
|
/*
|
|
Method dump skipped, instructions count: 259
|
|
To view this dump add '--comments-level debug' option
|
|
*/
|
|
throw new UnsupportedOperationException("Method not decompiled: androidx.constraintlayout.widget.ConstraintLayout.LayoutParams.resolveLayoutDirection(int):void");
|
|
}
|
|
}
|
|
|
|
@Override // android.view.View, android.view.ViewParent
|
|
public void requestLayout() {
|
|
markHierarchyDirty();
|
|
super.requestLayout();
|
|
}
|
|
|
|
@Override // android.view.View
|
|
public void forceLayout() {
|
|
markHierarchyDirty();
|
|
super.forceLayout();
|
|
}
|
|
|
|
public String getSceneString() {
|
|
int id;
|
|
StringBuilder sb = new StringBuilder();
|
|
if (this.mLayoutWidget.stringId == null) {
|
|
int id2 = getId();
|
|
if (id2 != -1) {
|
|
this.mLayoutWidget.stringId = getContext().getResources().getResourceEntryName(id2);
|
|
} else {
|
|
this.mLayoutWidget.stringId = "parent";
|
|
}
|
|
}
|
|
if (this.mLayoutWidget.getDebugName() == null) {
|
|
ConstraintWidgetContainer constraintWidgetContainer = this.mLayoutWidget;
|
|
constraintWidgetContainer.setDebugName(constraintWidgetContainer.stringId);
|
|
Log.v(TAG, " setDebugName " + this.mLayoutWidget.getDebugName());
|
|
}
|
|
Iterator<ConstraintWidget> it = this.mLayoutWidget.getChildren().iterator();
|
|
while (it.hasNext()) {
|
|
ConstraintWidget next = it.next();
|
|
View view = (View) next.getCompanionWidget();
|
|
if (view != null) {
|
|
if (next.stringId == null && (id = view.getId()) != -1) {
|
|
next.stringId = getContext().getResources().getResourceEntryName(id);
|
|
}
|
|
if (next.getDebugName() == null) {
|
|
next.setDebugName(next.stringId);
|
|
Log.v(TAG, " setDebugName " + next.getDebugName());
|
|
}
|
|
}
|
|
}
|
|
this.mLayoutWidget.getSceneString(sb);
|
|
return sb.toString();
|
|
}
|
|
}
|