548 lines
23 KiB
Java
548 lines
23 KiB
Java
package androidx.constraintlayout.solver.widgets.analyzer;
|
|
|
|
import androidx.constraintlayout.solver.widgets.ConstraintAnchor;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidget;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidgetContainer;
|
|
import c.d.b.a.a;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
public class ChainRun extends WidgetRun {
|
|
private int chainStyle;
|
|
public ArrayList<WidgetRun> widgets = new ArrayList<>();
|
|
|
|
public ChainRun(ConstraintWidget constraintWidget, int i) {
|
|
super(constraintWidget);
|
|
this.orientation = i;
|
|
build();
|
|
}
|
|
|
|
private void build() {
|
|
ConstraintWidget constraintWidget = this.widget;
|
|
ConstraintWidget previousChainMember = constraintWidget.getPreviousChainMember(this.orientation);
|
|
while (true) {
|
|
constraintWidget = previousChainMember;
|
|
if (constraintWidget == null) {
|
|
break;
|
|
}
|
|
previousChainMember = constraintWidget.getPreviousChainMember(this.orientation);
|
|
}
|
|
this.widget = constraintWidget;
|
|
this.widgets.add(constraintWidget.getRun(this.orientation));
|
|
ConstraintWidget nextChainMember = constraintWidget.getNextChainMember(this.orientation);
|
|
while (nextChainMember != null) {
|
|
this.widgets.add(nextChainMember.getRun(this.orientation));
|
|
nextChainMember = nextChainMember.getNextChainMember(this.orientation);
|
|
}
|
|
Iterator<WidgetRun> it = this.widgets.iterator();
|
|
while (it.hasNext()) {
|
|
WidgetRun next = it.next();
|
|
int i = this.orientation;
|
|
if (i == 0) {
|
|
next.widget.horizontalChainRun = this;
|
|
} else if (i == 1) {
|
|
next.widget.verticalChainRun = this;
|
|
}
|
|
}
|
|
if ((this.orientation == 0 && ((ConstraintWidgetContainer) this.widget.getParent()).isRtl()) && this.widgets.size() > 1) {
|
|
ArrayList<WidgetRun> arrayList = this.widgets;
|
|
this.widget = arrayList.get(arrayList.size() - 1).widget;
|
|
}
|
|
this.chainStyle = this.orientation == 0 ? this.widget.getHorizontalChainStyle() : this.widget.getVerticalChainStyle();
|
|
}
|
|
|
|
private ConstraintWidget getFirstVisibleWidget() {
|
|
for (int i = 0; i < this.widgets.size(); i++) {
|
|
WidgetRun widgetRun = this.widgets.get(i);
|
|
if (widgetRun.widget.getVisibility() != 8) {
|
|
return widgetRun.widget;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private ConstraintWidget getLastVisibleWidget() {
|
|
for (int size = this.widgets.size() - 1; size >= 0; size--) {
|
|
WidgetRun widgetRun = this.widgets.get(size);
|
|
if (widgetRun.widget.getVisibility() != 8) {
|
|
return widgetRun.widget;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public void apply() {
|
|
Iterator<WidgetRun> it = this.widgets.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().apply();
|
|
}
|
|
int size = this.widgets.size();
|
|
if (size >= 1) {
|
|
ConstraintWidget constraintWidget = this.widgets.get(0).widget;
|
|
ConstraintWidget constraintWidget2 = this.widgets.get(size - 1).widget;
|
|
if (this.orientation == 0) {
|
|
ConstraintAnchor constraintAnchor = constraintWidget.mLeft;
|
|
ConstraintAnchor constraintAnchor2 = constraintWidget2.mRight;
|
|
DependencyNode target = getTarget(constraintAnchor, 0);
|
|
int margin = constraintAnchor.getMargin();
|
|
ConstraintWidget firstVisibleWidget = getFirstVisibleWidget();
|
|
if (firstVisibleWidget != null) {
|
|
margin = firstVisibleWidget.mLeft.getMargin();
|
|
}
|
|
if (target != null) {
|
|
addTarget(this.start, target, margin);
|
|
}
|
|
DependencyNode target2 = getTarget(constraintAnchor2, 0);
|
|
int margin2 = constraintAnchor2.getMargin();
|
|
ConstraintWidget lastVisibleWidget = getLastVisibleWidget();
|
|
if (lastVisibleWidget != null) {
|
|
margin2 = lastVisibleWidget.mRight.getMargin();
|
|
}
|
|
if (target2 != null) {
|
|
addTarget(this.end, target2, -margin2);
|
|
}
|
|
} else {
|
|
ConstraintAnchor constraintAnchor3 = constraintWidget.mTop;
|
|
ConstraintAnchor constraintAnchor4 = constraintWidget2.mBottom;
|
|
DependencyNode target3 = getTarget(constraintAnchor3, 1);
|
|
int margin3 = constraintAnchor3.getMargin();
|
|
ConstraintWidget firstVisibleWidget2 = getFirstVisibleWidget();
|
|
if (firstVisibleWidget2 != null) {
|
|
margin3 = firstVisibleWidget2.mTop.getMargin();
|
|
}
|
|
if (target3 != null) {
|
|
addTarget(this.start, target3, margin3);
|
|
}
|
|
DependencyNode target4 = getTarget(constraintAnchor4, 1);
|
|
int margin4 = constraintAnchor4.getMargin();
|
|
ConstraintWidget lastVisibleWidget2 = getLastVisibleWidget();
|
|
if (lastVisibleWidget2 != null) {
|
|
margin4 = lastVisibleWidget2.mBottom.getMargin();
|
|
}
|
|
if (target4 != null) {
|
|
addTarget(this.end, target4, -margin4);
|
|
}
|
|
}
|
|
this.start.updateDelegate = this;
|
|
this.end.updateDelegate = this;
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public void applyToWidget() {
|
|
for (int i = 0; i < this.widgets.size(); i++) {
|
|
this.widgets.get(i).applyToWidget();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public void clear() {
|
|
this.runGroup = null;
|
|
Iterator<WidgetRun> it = this.widgets.iterator();
|
|
while (it.hasNext()) {
|
|
it.next().clear();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public long getWrapDimension() {
|
|
int size = this.widgets.size();
|
|
long j = 0;
|
|
for (int i = 0; i < size; i++) {
|
|
WidgetRun widgetRun = this.widgets.get(i);
|
|
j = ((long) widgetRun.end.margin) + widgetRun.getWrapDimension() + j + ((long) widgetRun.start.margin);
|
|
}
|
|
return j;
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public void reset() {
|
|
this.start.resolved = false;
|
|
this.end.resolved = false;
|
|
}
|
|
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun
|
|
public boolean supportsWrapComputation() {
|
|
int size = this.widgets.size();
|
|
for (int i = 0; i < size; i++) {
|
|
if (!this.widgets.get(i).supportsWrapComputation()) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public String toString() {
|
|
StringBuilder L = a.L("ChainRun ");
|
|
L.append(this.orientation == 0 ? "horizontal : " : "vertical : ");
|
|
String sb = L.toString();
|
|
Iterator<WidgetRun> it = this.widgets.iterator();
|
|
while (it.hasNext()) {
|
|
String t = a.t(sb, "<");
|
|
sb = a.t(t + it.next(), "> ");
|
|
}
|
|
return sb;
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:104:0x01a6, code lost:
|
|
if (r1 != r7) goto L_0x01ce;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:112:0x01cc, code lost:
|
|
if (r1 != r7) goto L_0x01ce;
|
|
*/
|
|
/* JADX WARNING: Removed duplicated region for block: B:60:0x00d9 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:63:0x00eb */
|
|
@Override // androidx.constraintlayout.solver.widgets.analyzer.WidgetRun, androidx.constraintlayout.solver.widgets.analyzer.Dependency
|
|
public void update(Dependency dependency) {
|
|
int i;
|
|
int i2;
|
|
int i3;
|
|
int i4;
|
|
int i5;
|
|
float f;
|
|
int i6;
|
|
boolean z2;
|
|
int i7;
|
|
int i8;
|
|
int i9;
|
|
boolean z3;
|
|
float f2;
|
|
int i10;
|
|
int i11;
|
|
int i12;
|
|
int i13;
|
|
int i14;
|
|
int i15;
|
|
if (this.start.resolved && this.end.resolved) {
|
|
ConstraintWidget parent = this.widget.getParent();
|
|
boolean isRtl = (parent == null || !(parent instanceof ConstraintWidgetContainer)) ? false : ((ConstraintWidgetContainer) parent).isRtl();
|
|
int i16 = this.end.value - this.start.value;
|
|
int size = this.widgets.size();
|
|
int i17 = 0;
|
|
while (true) {
|
|
i = -1;
|
|
i2 = 8;
|
|
if (i17 >= size) {
|
|
i17 = -1;
|
|
break;
|
|
}
|
|
if (this.widgets.get(i17).widget.getVisibility() != 8) {
|
|
break;
|
|
}
|
|
i17++;
|
|
}
|
|
int i18 = size - 1;
|
|
int i19 = i18;
|
|
while (true) {
|
|
if (i19 < 0) {
|
|
break;
|
|
}
|
|
if (this.widgets.get(i19).widget.getVisibility() != 8) {
|
|
i = i19;
|
|
break;
|
|
}
|
|
i19--;
|
|
}
|
|
int i20 = 0;
|
|
while (true) {
|
|
if (i20 >= 2) {
|
|
i3 = 0;
|
|
i4 = 0;
|
|
i5 = 0;
|
|
f = 0.0f;
|
|
break;
|
|
}
|
|
int i21 = 0;
|
|
i4 = 0;
|
|
i5 = 0;
|
|
i13 = 0;
|
|
f = 0.0f;
|
|
while (i21 < size) {
|
|
WidgetRun widgetRun = this.widgets.get(i21);
|
|
if (widgetRun.widget.getVisibility() != i2) {
|
|
i13++;
|
|
if (i21 > 0 && i21 >= i17) {
|
|
i4 += widgetRun.start.margin;
|
|
}
|
|
DimensionDependency dimensionDependency = widgetRun.dimension;
|
|
int i22 = dimensionDependency.value;
|
|
boolean z4 = widgetRun.dimensionBehavior != ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
|
|
if (z4) {
|
|
int i23 = this.orientation;
|
|
if (i23 == 0 && !widgetRun.widget.horizontalRun.dimension.resolved) {
|
|
return;
|
|
}
|
|
if (i23 != 1 || widgetRun.widget.verticalRun.dimension.resolved) {
|
|
i15 = i22;
|
|
} else {
|
|
return;
|
|
}
|
|
} else {
|
|
i15 = i22;
|
|
if (widgetRun.matchConstraintsType == 1 && i20 == 0) {
|
|
i14 = dimensionDependency.wrapValue;
|
|
i5++;
|
|
} else if (dimensionDependency.resolved) {
|
|
i14 = i15;
|
|
}
|
|
z4 = true;
|
|
if (z4) {
|
|
i5++;
|
|
float f3 = widgetRun.widget.mWeight[this.orientation];
|
|
if (f3 >= 0.0f) {
|
|
f += f3;
|
|
}
|
|
} else {
|
|
i4 += i14;
|
|
}
|
|
if (i21 < i18 && i21 < i) {
|
|
i4 += -widgetRun.end.margin;
|
|
}
|
|
}
|
|
i14 = i15;
|
|
if (z4) {
|
|
}
|
|
i4 += -widgetRun.end.margin;
|
|
}
|
|
i21++;
|
|
i2 = 8;
|
|
}
|
|
if (i4 < i16 || i5 == 0) {
|
|
break;
|
|
}
|
|
i20++;
|
|
i2 = 8;
|
|
}
|
|
i3 = i13;
|
|
int i24 = this.start.value;
|
|
if (isRtl) {
|
|
i24 = this.end.value;
|
|
}
|
|
if (i4 > i16) {
|
|
i24 = isRtl ? i24 + ((int) ((((float) (i4 - i16)) / 2.0f) + 0.5f)) : i24 - ((int) ((((float) (i4 - i16)) / 2.0f) + 0.5f));
|
|
}
|
|
if (i5 > 0) {
|
|
float f4 = (float) (i16 - i4);
|
|
int i25 = (int) ((f4 / ((float) i5)) + 0.5f);
|
|
int i26 = 0;
|
|
int i27 = 0;
|
|
while (i26 < size) {
|
|
WidgetRun widgetRun2 = this.widgets.get(i26);
|
|
if (widgetRun2.widget.getVisibility() != 8 && widgetRun2.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
|
|
DimensionDependency dimensionDependency2 = widgetRun2.dimension;
|
|
if (!dimensionDependency2.resolved) {
|
|
if (f > 0.0f) {
|
|
i10 = i24;
|
|
i11 = (int) (((widgetRun2.widget.mWeight[this.orientation] * f4) / f) + 0.5f);
|
|
} else {
|
|
i10 = i24;
|
|
i11 = i25;
|
|
}
|
|
if (this.orientation == 0) {
|
|
ConstraintWidget constraintWidget = widgetRun2.widget;
|
|
f2 = f4;
|
|
int i28 = constraintWidget.mMatchConstraintMaxWidth;
|
|
z3 = isRtl;
|
|
i9 = i3;
|
|
i12 = Math.max(constraintWidget.mMatchConstraintMinWidth, widgetRun2.matchConstraintsType == 1 ? Math.min(i11, dimensionDependency2.wrapValue) : i11);
|
|
if (i28 > 0) {
|
|
i12 = Math.min(i28, i12);
|
|
}
|
|
} else {
|
|
z3 = isRtl;
|
|
i9 = i3;
|
|
f2 = f4;
|
|
ConstraintWidget constraintWidget2 = widgetRun2.widget;
|
|
int i29 = constraintWidget2.mMatchConstraintMaxHeight;
|
|
i12 = Math.max(constraintWidget2.mMatchConstraintMinHeight, widgetRun2.matchConstraintsType == 1 ? Math.min(i11, dimensionDependency2.wrapValue) : i11);
|
|
if (i29 > 0) {
|
|
i12 = Math.min(i29, i12);
|
|
}
|
|
}
|
|
i27++;
|
|
i11 = i12;
|
|
widgetRun2.dimension.resolve(i11);
|
|
i26++;
|
|
i25 = i25;
|
|
i4 = i4;
|
|
i24 = i10;
|
|
f4 = f2;
|
|
isRtl = z3;
|
|
i3 = i9;
|
|
}
|
|
}
|
|
z3 = isRtl;
|
|
i9 = i3;
|
|
i10 = i24;
|
|
f2 = f4;
|
|
i26++;
|
|
i25 = i25;
|
|
i4 = i4;
|
|
i24 = i10;
|
|
f4 = f2;
|
|
isRtl = z3;
|
|
i3 = i9;
|
|
}
|
|
z2 = isRtl;
|
|
i6 = i3;
|
|
i7 = i24;
|
|
if (i27 > 0) {
|
|
i5 -= i27;
|
|
int i30 = 0;
|
|
for (int i31 = 0; i31 < size; i31++) {
|
|
WidgetRun widgetRun3 = this.widgets.get(i31);
|
|
if (widgetRun3.widget.getVisibility() != 8) {
|
|
if (i31 > 0 && i31 >= i17) {
|
|
i30 += widgetRun3.start.margin;
|
|
}
|
|
i30 += widgetRun3.dimension.value;
|
|
if (i31 < i18 && i31 < i) {
|
|
i30 += -widgetRun3.end.margin;
|
|
}
|
|
}
|
|
}
|
|
i4 = i30;
|
|
} else {
|
|
i4 = i4;
|
|
}
|
|
i8 = 2;
|
|
if (this.chainStyle == 2 && i27 == 0) {
|
|
this.chainStyle = 0;
|
|
}
|
|
} else {
|
|
z2 = isRtl;
|
|
i6 = i3;
|
|
i7 = i24;
|
|
i8 = 2;
|
|
}
|
|
if (i4 > i16) {
|
|
this.chainStyle = i8;
|
|
}
|
|
if (i6 > 0 && i5 == 0 && i17 == i) {
|
|
this.chainStyle = i8;
|
|
}
|
|
int i32 = this.chainStyle;
|
|
if (i32 == 1) {
|
|
int i33 = i6 > 1 ? (i16 - i4) / (i6 - 1) : i6 == 1 ? (i16 - i4) / 2 : 0;
|
|
if (i5 > 0) {
|
|
i33 = 0;
|
|
}
|
|
int i34 = i7;
|
|
for (int i35 = 0; i35 < size; i35++) {
|
|
WidgetRun widgetRun4 = this.widgets.get(z2 ? size - (i35 + 1) : i35);
|
|
if (widgetRun4.widget.getVisibility() == 8) {
|
|
widgetRun4.start.resolve(i34);
|
|
widgetRun4.end.resolve(i34);
|
|
} else {
|
|
if (i35 > 0) {
|
|
i34 = z2 ? i34 - i33 : i34 + i33;
|
|
}
|
|
if (i35 > 0 && i35 >= i17) {
|
|
i34 = z2 ? i34 - widgetRun4.start.margin : i34 + widgetRun4.start.margin;
|
|
}
|
|
if (z2) {
|
|
widgetRun4.end.resolve(i34);
|
|
} else {
|
|
widgetRun4.start.resolve(i34);
|
|
}
|
|
DimensionDependency dimensionDependency3 = widgetRun4.dimension;
|
|
int i36 = dimensionDependency3.value;
|
|
if (widgetRun4.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && widgetRun4.matchConstraintsType == 1) {
|
|
i36 = dimensionDependency3.wrapValue;
|
|
}
|
|
i34 = z2 ? i34 - i36 : i34 + i36;
|
|
if (z2) {
|
|
widgetRun4.start.resolve(i34);
|
|
} else {
|
|
widgetRun4.end.resolve(i34);
|
|
}
|
|
widgetRun4.resolved = true;
|
|
if (i35 < i18 && i35 < i) {
|
|
i34 = z2 ? i34 - (-widgetRun4.end.margin) : i34 + (-widgetRun4.end.margin);
|
|
}
|
|
}
|
|
}
|
|
} else if (i32 == 0) {
|
|
int i37 = (i16 - i4) / (i6 + 1);
|
|
if (i5 > 0) {
|
|
i37 = 0;
|
|
}
|
|
int i38 = i7;
|
|
for (int i39 = 0; i39 < size; i39++) {
|
|
WidgetRun widgetRun5 = this.widgets.get(z2 ? size - (i39 + 1) : i39);
|
|
if (widgetRun5.widget.getVisibility() == 8) {
|
|
widgetRun5.start.resolve(i38);
|
|
widgetRun5.end.resolve(i38);
|
|
} else {
|
|
int i40 = z2 ? i38 - i37 : i38 + i37;
|
|
if (i39 > 0 && i39 >= i17) {
|
|
i40 = z2 ? i40 - widgetRun5.start.margin : i40 + widgetRun5.start.margin;
|
|
}
|
|
if (z2) {
|
|
widgetRun5.end.resolve(i40);
|
|
} else {
|
|
widgetRun5.start.resolve(i40);
|
|
}
|
|
DimensionDependency dimensionDependency4 = widgetRun5.dimension;
|
|
int i41 = dimensionDependency4.value;
|
|
if (widgetRun5.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && widgetRun5.matchConstraintsType == 1) {
|
|
i41 = Math.min(i41, dimensionDependency4.wrapValue);
|
|
}
|
|
i38 = z2 ? i40 - i41 : i40 + i41;
|
|
if (z2) {
|
|
widgetRun5.start.resolve(i38);
|
|
} else {
|
|
widgetRun5.end.resolve(i38);
|
|
}
|
|
if (i39 < i18 && i39 < i) {
|
|
i38 = z2 ? i38 - (-widgetRun5.end.margin) : i38 + (-widgetRun5.end.margin);
|
|
}
|
|
}
|
|
}
|
|
} else if (i32 == 2) {
|
|
float horizontalBiasPercent = this.orientation == 0 ? this.widget.getHorizontalBiasPercent() : this.widget.getVerticalBiasPercent();
|
|
if (z2) {
|
|
horizontalBiasPercent = 1.0f - horizontalBiasPercent;
|
|
}
|
|
int i42 = (int) ((((float) (i16 - i4)) * horizontalBiasPercent) + 0.5f);
|
|
if (i42 < 0 || i5 > 0) {
|
|
i42 = 0;
|
|
}
|
|
int i43 = z2 ? i7 - i42 : i7 + i42;
|
|
for (int i44 = 0; i44 < size; i44++) {
|
|
WidgetRun widgetRun6 = this.widgets.get(z2 ? size - (i44 + 1) : i44);
|
|
if (widgetRun6.widget.getVisibility() == 8) {
|
|
widgetRun6.start.resolve(i43);
|
|
widgetRun6.end.resolve(i43);
|
|
} else {
|
|
if (i44 > 0 && i44 >= i17) {
|
|
i43 = z2 ? i43 - widgetRun6.start.margin : i43 + widgetRun6.start.margin;
|
|
}
|
|
if (z2) {
|
|
widgetRun6.end.resolve(i43);
|
|
} else {
|
|
widgetRun6.start.resolve(i43);
|
|
}
|
|
DimensionDependency dimensionDependency5 = widgetRun6.dimension;
|
|
int i45 = dimensionDependency5.value;
|
|
if (widgetRun6.dimensionBehavior == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
|
|
if (widgetRun6.matchConstraintsType == 1) {
|
|
i45 = dimensionDependency5.wrapValue;
|
|
}
|
|
}
|
|
i43 = z2 ? i43 - i45 : i43 + i45;
|
|
if (z2) {
|
|
widgetRun6.start.resolve(i43);
|
|
} else {
|
|
widgetRun6.end.resolve(i43);
|
|
}
|
|
if (i44 < i18 && i44 < i) {
|
|
i43 = z2 ? i43 - (-widgetRun6.end.margin) : i43 + (-widgetRun6.end.margin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|