642 lines
41 KiB
Java
642 lines
41 KiB
Java
package androidx.constraintlayout.solver.widgets.analyzer;
|
|
|
|
import androidx.constraintlayout.solver.LinearSystem;
|
|
import androidx.constraintlayout.solver.widgets.Barrier;
|
|
import androidx.constraintlayout.solver.widgets.ChainHead;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintAnchor;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidget;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidgetContainer;
|
|
import androidx.constraintlayout.solver.widgets.Guideline;
|
|
import androidx.constraintlayout.solver.widgets.analyzer.BasicMeasure;
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
public class Direct {
|
|
private static final boolean APPLY_MATCH_PARENT = false;
|
|
private static final boolean DEBUG = false;
|
|
private static BasicMeasure.Measure measure = new BasicMeasure.Measure();
|
|
|
|
private static boolean canMeasure(ConstraintWidget constraintWidget) {
|
|
ConstraintWidget.DimensionBehaviour horizontalDimensionBehaviour = constraintWidget.getHorizontalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour verticalDimensionBehaviour = constraintWidget.getVerticalDimensionBehaviour();
|
|
ConstraintWidgetContainer constraintWidgetContainer = constraintWidget.getParent() != null ? (ConstraintWidgetContainer) constraintWidget.getParent() : null;
|
|
if (constraintWidgetContainer != null) {
|
|
constraintWidgetContainer.getHorizontalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour = ConstraintWidget.DimensionBehaviour.FIXED;
|
|
}
|
|
if (constraintWidgetContainer != null) {
|
|
constraintWidgetContainer.getVerticalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.FIXED;
|
|
}
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour3 = ConstraintWidget.DimensionBehaviour.FIXED;
|
|
boolean z2 = horizontalDimensionBehaviour == dimensionBehaviour3 || horizontalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.WRAP_CONTENT || (horizontalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && constraintWidget.mMatchConstraintDefaultWidth == 0 && constraintWidget.mDimensionRatio == 0.0f && constraintWidget.hasDanglingDimension(0)) || constraintWidget.isResolvedHorizontally();
|
|
boolean z3 = verticalDimensionBehaviour == dimensionBehaviour3 || verticalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.WRAP_CONTENT || (verticalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT && constraintWidget.mMatchConstraintDefaultHeight == 0 && constraintWidget.mDimensionRatio == 0.0f && constraintWidget.hasDanglingDimension(1)) || constraintWidget.isResolvedVertically();
|
|
if (constraintWidget.mDimensionRatio <= 0.0f || (!z2 && !z3)) {
|
|
return z2 && z3;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private static void horizontalSolvingPass(ConstraintWidget constraintWidget, BasicMeasure.Measurer measurer, boolean z2) {
|
|
ConstraintAnchor constraintAnchor;
|
|
ConstraintAnchor constraintAnchor2;
|
|
ConstraintAnchor constraintAnchor3;
|
|
ConstraintAnchor constraintAnchor4;
|
|
ConstraintAnchor constraintAnchor5;
|
|
if (!(constraintWidget instanceof ConstraintWidgetContainer) && constraintWidget.isMeasureRequested() && canMeasure(constraintWidget)) {
|
|
ConstraintWidgetContainer.measure(constraintWidget, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
ConstraintAnchor anchor = constraintWidget.getAnchor(ConstraintAnchor.Type.LEFT);
|
|
ConstraintAnchor anchor2 = constraintWidget.getAnchor(ConstraintAnchor.Type.RIGHT);
|
|
int finalValue = anchor.getFinalValue();
|
|
int finalValue2 = anchor2.getFinalValue();
|
|
if (anchor.getDependents() != null && anchor.hasFinalValue()) {
|
|
Iterator<ConstraintAnchor> it = anchor.getDependents().iterator();
|
|
while (it.hasNext()) {
|
|
ConstraintAnchor next = it.next();
|
|
ConstraintWidget constraintWidget2 = next.mOwner;
|
|
boolean canMeasure = canMeasure(constraintWidget2);
|
|
if (constraintWidget2.isMeasureRequested() && canMeasure) {
|
|
ConstraintWidgetContainer.measure(constraintWidget2, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
ConstraintWidget.DimensionBehaviour horizontalDimensionBehaviour = constraintWidget2.getHorizontalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour = ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
|
|
if (horizontalDimensionBehaviour != dimensionBehaviour || canMeasure) {
|
|
if (!constraintWidget2.isMeasureRequested()) {
|
|
ConstraintAnchor constraintAnchor6 = constraintWidget2.mLeft;
|
|
if (next == constraintAnchor6 && constraintWidget2.mRight.mTarget == null) {
|
|
int margin = constraintAnchor6.getMargin() + finalValue;
|
|
constraintWidget2.setFinalHorizontal(margin, constraintWidget2.getWidth() + margin);
|
|
horizontalSolvingPass(constraintWidget2, measurer, z2);
|
|
} else {
|
|
ConstraintAnchor constraintAnchor7 = constraintWidget2.mRight;
|
|
if (next == constraintAnchor7 && constraintAnchor6.mTarget == null) {
|
|
int margin2 = finalValue - constraintAnchor7.getMargin();
|
|
constraintWidget2.setFinalHorizontal(margin2 - constraintWidget2.getWidth(), margin2);
|
|
horizontalSolvingPass(constraintWidget2, measurer, z2);
|
|
} else if (next == constraintAnchor6 && (constraintAnchor3 = constraintAnchor7.mTarget) != null && constraintAnchor3.hasFinalValue() && !constraintWidget2.isInHorizontalChain()) {
|
|
solveHorizontalCenterConstraints(measurer, constraintWidget2, z2);
|
|
}
|
|
}
|
|
}
|
|
} else if (constraintWidget2.getHorizontalDimensionBehaviour() == dimensionBehaviour && constraintWidget2.mMatchConstraintMaxWidth >= 0 && constraintWidget2.mMatchConstraintMinWidth >= 0) {
|
|
if (constraintWidget2.getVisibility() == 8 || (constraintWidget2.mMatchConstraintDefaultWidth == 0 && constraintWidget2.getDimensionRatio() == 0.0f)) {
|
|
if (!constraintWidget2.isInHorizontalChain() && !constraintWidget2.isInVirtualLayout()) {
|
|
if (((next == constraintWidget2.mLeft && (constraintAnchor5 = constraintWidget2.mRight.mTarget) != null && constraintAnchor5.hasFinalValue()) || (next == constraintWidget2.mRight && (constraintAnchor4 = constraintWidget2.mLeft.mTarget) != null && constraintAnchor4.hasFinalValue())) && !constraintWidget2.isInHorizontalChain()) {
|
|
solveHorizontalMatchConstraint(constraintWidget, measurer, constraintWidget2, z2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!(constraintWidget instanceof Guideline) && anchor2.getDependents() != null && anchor2.hasFinalValue()) {
|
|
Iterator<ConstraintAnchor> it2 = anchor2.getDependents().iterator();
|
|
while (it2.hasNext()) {
|
|
ConstraintAnchor next2 = it2.next();
|
|
ConstraintWidget constraintWidget3 = next2.mOwner;
|
|
boolean canMeasure2 = canMeasure(constraintWidget3);
|
|
if (constraintWidget3.isMeasureRequested() && canMeasure2) {
|
|
ConstraintWidgetContainer.measure(constraintWidget3, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
boolean z3 = (next2 == constraintWidget3.mLeft && (constraintAnchor2 = constraintWidget3.mRight.mTarget) != null && constraintAnchor2.hasFinalValue()) || (next2 == constraintWidget3.mRight && (constraintAnchor = constraintWidget3.mLeft.mTarget) != null && constraintAnchor.hasFinalValue());
|
|
ConstraintWidget.DimensionBehaviour horizontalDimensionBehaviour2 = constraintWidget3.getHorizontalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
|
|
if (horizontalDimensionBehaviour2 != dimensionBehaviour2 || canMeasure2) {
|
|
if (!constraintWidget3.isMeasureRequested()) {
|
|
ConstraintAnchor constraintAnchor8 = constraintWidget3.mLeft;
|
|
if (next2 == constraintAnchor8 && constraintWidget3.mRight.mTarget == null) {
|
|
int margin3 = constraintAnchor8.getMargin() + finalValue2;
|
|
constraintWidget3.setFinalHorizontal(margin3, constraintWidget3.getWidth() + margin3);
|
|
horizontalSolvingPass(constraintWidget3, measurer, z2);
|
|
} else {
|
|
ConstraintAnchor constraintAnchor9 = constraintWidget3.mRight;
|
|
if (next2 == constraintAnchor9 && constraintAnchor8.mTarget == null) {
|
|
int margin4 = finalValue2 - constraintAnchor9.getMargin();
|
|
constraintWidget3.setFinalHorizontal(margin4 - constraintWidget3.getWidth(), margin4);
|
|
horizontalSolvingPass(constraintWidget3, measurer, z2);
|
|
} else if (z3 && !constraintWidget3.isInHorizontalChain()) {
|
|
solveHorizontalCenterConstraints(measurer, constraintWidget3, z2);
|
|
}
|
|
}
|
|
}
|
|
} else if (constraintWidget3.getHorizontalDimensionBehaviour() == dimensionBehaviour2 && constraintWidget3.mMatchConstraintMaxWidth >= 0 && constraintWidget3.mMatchConstraintMinWidth >= 0) {
|
|
if (constraintWidget3.getVisibility() == 8 || (constraintWidget3.mMatchConstraintDefaultWidth == 0 && constraintWidget3.getDimensionRatio() == 0.0f)) {
|
|
if (!constraintWidget3.isInHorizontalChain() && !constraintWidget3.isInVirtualLayout() && z3 && !constraintWidget3.isInHorizontalChain()) {
|
|
solveHorizontalMatchConstraint(constraintWidget, measurer, constraintWidget3, z2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void solveBarrier(Barrier barrier, BasicMeasure.Measurer measurer, int i, boolean z2) {
|
|
if (!barrier.allSolved()) {
|
|
return;
|
|
}
|
|
if (i == 0) {
|
|
horizontalSolvingPass(barrier, measurer, z2);
|
|
} else {
|
|
verticalSolvingPass(barrier, measurer);
|
|
}
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:97:0x01db, code lost:
|
|
if (r6[r21].mTarget.mOwner == r2) goto L_0x01df;
|
|
*/
|
|
/* JADX WARNING: Removed duplicated region for block: B:69:0x0120 */
|
|
/* JADX WARNING: Removed duplicated region for block: B:78:0x0150 */
|
|
public static boolean solveChain(ConstraintWidgetContainer constraintWidgetContainer, LinearSystem linearSystem, int i, int i2, ChainHead chainHead, boolean z2, boolean z3, boolean z4) {
|
|
int margin;
|
|
int finalValue;
|
|
int finalValue2;
|
|
int i3;
|
|
boolean z5;
|
|
LinearSystem linearSystem2;
|
|
ConstraintWidget constraintWidget;
|
|
int i4;
|
|
if (z4) {
|
|
return false;
|
|
}
|
|
if (i == 0) {
|
|
if (!constraintWidgetContainer.isResolvedHorizontally()) {
|
|
return false;
|
|
}
|
|
} else if (!constraintWidgetContainer.isResolvedVertically()) {
|
|
return false;
|
|
}
|
|
boolean isRtl = constraintWidgetContainer.isRtl();
|
|
ConstraintWidget first = chainHead.getFirst();
|
|
ConstraintWidget last = chainHead.getLast();
|
|
ConstraintWidget firstVisibleWidget = chainHead.getFirstVisibleWidget();
|
|
ConstraintWidget lastVisibleWidget = chainHead.getLastVisibleWidget();
|
|
ConstraintWidget head = chainHead.getHead();
|
|
ConstraintAnchor constraintAnchor = first.mListAnchors[i2];
|
|
int i5 = i2 + 1;
|
|
ConstraintAnchor constraintAnchor2 = last.mListAnchors[i5];
|
|
ConstraintAnchor constraintAnchor3 = constraintAnchor.mTarget;
|
|
if (constraintAnchor3 == null || constraintAnchor2.mTarget == null || !constraintAnchor3.hasFinalValue() || !constraintAnchor2.mTarget.hasFinalValue() || firstVisibleWidget == null || lastVisibleWidget == null || (finalValue2 = (finalValue = constraintAnchor2.mTarget.getFinalValue() - lastVisibleWidget.mListAnchors[i5].getMargin()) - (margin = firstVisibleWidget.mListAnchors[i2].getMargin() + constraintAnchor.mTarget.getFinalValue())) <= 0) {
|
|
return false;
|
|
}
|
|
BasicMeasure.Measure measure2 = new BasicMeasure.Measure();
|
|
ConstraintWidget constraintWidget2 = first;
|
|
boolean z6 = false;
|
|
int i6 = 0;
|
|
int i7 = 0;
|
|
int i8 = 0;
|
|
while (true) {
|
|
ConstraintWidget constraintWidget3 = null;
|
|
if (!z6) {
|
|
ConstraintAnchor constraintAnchor4 = constraintWidget2.mListAnchors[i2];
|
|
if (!canMeasure(constraintWidget2) || constraintWidget2.mListDimensionBehaviors[i] == ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT) {
|
|
return false;
|
|
}
|
|
if (constraintWidget2.isMeasureRequested()) {
|
|
ConstraintWidgetContainer.measure(constraintWidget2, constraintWidgetContainer.getMeasurer(), measure2, BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
i8 = constraintWidget2.mListAnchors[i5].getMargin() + (i == 0 ? constraintWidget2.getWidth() : constraintWidget2.getHeight()) + constraintWidget2.mListAnchors[i2].getMargin() + i8;
|
|
i7++;
|
|
if (constraintWidget2.getVisibility() != 8) {
|
|
i6++;
|
|
}
|
|
ConstraintAnchor constraintAnchor5 = constraintWidget2.mListAnchors[i5].mTarget;
|
|
if (constraintAnchor5 != null) {
|
|
ConstraintWidget constraintWidget4 = constraintAnchor5.mOwner;
|
|
ConstraintAnchor[] constraintAnchorArr = constraintWidget4.mListAnchors;
|
|
if (constraintAnchorArr[i2].mTarget != null && constraintAnchorArr[i2].mTarget.mOwner == constraintWidget2) {
|
|
constraintWidget3 = constraintWidget4;
|
|
}
|
|
}
|
|
if (constraintWidget3 != null) {
|
|
constraintWidget2 = constraintWidget3;
|
|
} else {
|
|
z6 = true;
|
|
}
|
|
first = first;
|
|
} else if (i6 == 0 || i6 != i7 || finalValue2 < i8) {
|
|
return false;
|
|
} else {
|
|
int i9 = finalValue2 - i8;
|
|
if (z2) {
|
|
i9 /= i6 + 1;
|
|
} else if (z3 && i6 > 2) {
|
|
i3 = 1;
|
|
i9 = (i9 / i6) - 1;
|
|
if (i6 != i3) {
|
|
int horizontalBiasPercent = (int) ((((float) i9) * (i == 0 ? head.getHorizontalBiasPercent() : head.getVerticalBiasPercent())) + ((float) margin) + 0.5f);
|
|
if (i == 0) {
|
|
firstVisibleWidget.setFinalHorizontal(horizontalBiasPercent, firstVisibleWidget.getWidth() + horizontalBiasPercent);
|
|
} else {
|
|
firstVisibleWidget.setFinalVertical(horizontalBiasPercent, firstVisibleWidget.getHeight() + horizontalBiasPercent);
|
|
}
|
|
horizontalSolvingPass(firstVisibleWidget, constraintWidgetContainer.getMeasurer(), isRtl);
|
|
return true;
|
|
}
|
|
if (z2) {
|
|
int i10 = margin + i9;
|
|
ConstraintWidget constraintWidget5 = first;
|
|
boolean z7 = false;
|
|
while (!z7) {
|
|
ConstraintAnchor constraintAnchor6 = constraintWidget5.mListAnchors[i2];
|
|
if (constraintWidget5.getVisibility() == 8) {
|
|
if (i == 0) {
|
|
constraintWidget5.setFinalHorizontal(i10, i10);
|
|
horizontalSolvingPass(constraintWidget5, constraintWidgetContainer.getMeasurer(), isRtl);
|
|
} else {
|
|
constraintWidget5.setFinalVertical(i10, i10);
|
|
verticalSolvingPass(constraintWidget5, constraintWidgetContainer.getMeasurer());
|
|
}
|
|
linearSystem2 = linearSystem;
|
|
z5 = false;
|
|
} else {
|
|
int margin2 = constraintWidget5.mListAnchors[i2].getMargin() + i10;
|
|
if (i == 0) {
|
|
constraintWidget5.setFinalHorizontal(margin2, constraintWidget5.getWidth() + margin2);
|
|
horizontalSolvingPass(constraintWidget5, constraintWidgetContainer.getMeasurer(), isRtl);
|
|
i4 = constraintWidget5.getWidth();
|
|
} else {
|
|
constraintWidget5.setFinalVertical(margin2, constraintWidget5.getHeight() + margin2);
|
|
verticalSolvingPass(constraintWidget5, constraintWidgetContainer.getMeasurer());
|
|
i4 = constraintWidget5.getHeight();
|
|
}
|
|
i10 = constraintWidget5.mListAnchors[i5].getMargin() + i4 + margin2 + i9;
|
|
z5 = false;
|
|
linearSystem2 = linearSystem;
|
|
}
|
|
constraintWidget5.addToSolver(linearSystem2, z5);
|
|
ConstraintAnchor constraintAnchor7 = constraintWidget5.mListAnchors[i5].mTarget;
|
|
if (constraintAnchor7 != null) {
|
|
constraintWidget = constraintAnchor7.mOwner;
|
|
ConstraintAnchor[] constraintAnchorArr2 = constraintWidget.mListAnchors;
|
|
if (constraintAnchorArr2[i2].mTarget != null) {
|
|
}
|
|
}
|
|
constraintWidget = null;
|
|
if (constraintWidget != null) {
|
|
constraintWidget5 = constraintWidget;
|
|
} else {
|
|
z7 = true;
|
|
}
|
|
}
|
|
} else if (z3) {
|
|
if (i6 != 2) {
|
|
return false;
|
|
}
|
|
if (i == 0) {
|
|
firstVisibleWidget.setFinalHorizontal(margin, firstVisibleWidget.getWidth() + margin);
|
|
lastVisibleWidget.setFinalHorizontal(finalValue - lastVisibleWidget.getWidth(), finalValue);
|
|
horizontalSolvingPass(firstVisibleWidget, constraintWidgetContainer.getMeasurer(), isRtl);
|
|
horizontalSolvingPass(lastVisibleWidget, constraintWidgetContainer.getMeasurer(), isRtl);
|
|
return true;
|
|
}
|
|
firstVisibleWidget.setFinalVertical(margin, firstVisibleWidget.getHeight() + margin);
|
|
lastVisibleWidget.setFinalVertical(finalValue - lastVisibleWidget.getHeight(), finalValue);
|
|
verticalSolvingPass(firstVisibleWidget, constraintWidgetContainer.getMeasurer());
|
|
verticalSolvingPass(lastVisibleWidget, constraintWidgetContainer.getMeasurer());
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
i3 = 1;
|
|
if (i6 != i3) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void solveHorizontalCenterConstraints(BasicMeasure.Measurer measurer, ConstraintWidget constraintWidget, boolean z2) {
|
|
float horizontalBiasPercent = constraintWidget.getHorizontalBiasPercent();
|
|
int finalValue = constraintWidget.mLeft.mTarget.getFinalValue();
|
|
int finalValue2 = constraintWidget.mRight.mTarget.getFinalValue();
|
|
int margin = constraintWidget.mLeft.getMargin() + finalValue;
|
|
int margin2 = finalValue2 - constraintWidget.mRight.getMargin();
|
|
if (finalValue == finalValue2) {
|
|
horizontalBiasPercent = 0.5f;
|
|
} else {
|
|
finalValue = margin;
|
|
finalValue2 = margin2;
|
|
}
|
|
int width = constraintWidget.getWidth();
|
|
int i = (finalValue2 - finalValue) - width;
|
|
if (finalValue > finalValue2) {
|
|
i = (finalValue - finalValue2) - width;
|
|
}
|
|
int i2 = ((int) ((horizontalBiasPercent * ((float) i)) + 0.5f)) + finalValue;
|
|
int i3 = i2 + width;
|
|
if (finalValue > finalValue2) {
|
|
i3 = i2 - width;
|
|
}
|
|
constraintWidget.setFinalHorizontal(i2, i3);
|
|
horizontalSolvingPass(constraintWidget, measurer, z2);
|
|
}
|
|
|
|
private static void solveHorizontalMatchConstraint(ConstraintWidget constraintWidget, BasicMeasure.Measurer measurer, ConstraintWidget constraintWidget2, boolean z2) {
|
|
float horizontalBiasPercent = constraintWidget2.getHorizontalBiasPercent();
|
|
int margin = constraintWidget2.mLeft.getMargin() + constraintWidget2.mLeft.mTarget.getFinalValue();
|
|
int finalValue = constraintWidget2.mRight.mTarget.getFinalValue() - constraintWidget2.mRight.getMargin();
|
|
if (finalValue >= margin) {
|
|
int width = constraintWidget2.getWidth();
|
|
if (constraintWidget2.getVisibility() != 8) {
|
|
int i = constraintWidget2.mMatchConstraintDefaultWidth;
|
|
if (i == 2) {
|
|
width = (int) (constraintWidget2.getHorizontalBiasPercent() * 0.5f * ((float) (constraintWidget instanceof ConstraintWidgetContainer ? constraintWidget.getWidth() : constraintWidget.getParent().getWidth())));
|
|
} else if (i == 0) {
|
|
width = finalValue - margin;
|
|
}
|
|
width = Math.max(constraintWidget2.mMatchConstraintMinWidth, width);
|
|
int i2 = constraintWidget2.mMatchConstraintMaxWidth;
|
|
if (i2 > 0) {
|
|
width = Math.min(i2, width);
|
|
}
|
|
}
|
|
int i3 = margin + ((int) ((horizontalBiasPercent * ((float) ((finalValue - margin) - width))) + 0.5f));
|
|
constraintWidget2.setFinalHorizontal(i3, width + i3);
|
|
horizontalSolvingPass(constraintWidget2, measurer, z2);
|
|
}
|
|
}
|
|
|
|
private static void solveVerticalCenterConstraints(BasicMeasure.Measurer measurer, ConstraintWidget constraintWidget) {
|
|
float verticalBiasPercent = constraintWidget.getVerticalBiasPercent();
|
|
int finalValue = constraintWidget.mTop.mTarget.getFinalValue();
|
|
int finalValue2 = constraintWidget.mBottom.mTarget.getFinalValue();
|
|
int margin = constraintWidget.mTop.getMargin() + finalValue;
|
|
int margin2 = finalValue2 - constraintWidget.mBottom.getMargin();
|
|
if (finalValue == finalValue2) {
|
|
verticalBiasPercent = 0.5f;
|
|
} else {
|
|
finalValue = margin;
|
|
finalValue2 = margin2;
|
|
}
|
|
int height = constraintWidget.getHeight();
|
|
int i = (finalValue2 - finalValue) - height;
|
|
if (finalValue > finalValue2) {
|
|
i = (finalValue - finalValue2) - height;
|
|
}
|
|
int i2 = (int) ((verticalBiasPercent * ((float) i)) + 0.5f);
|
|
int i3 = finalValue + i2;
|
|
int i4 = i3 + height;
|
|
if (finalValue > finalValue2) {
|
|
i3 = finalValue - i2;
|
|
i4 = i3 - height;
|
|
}
|
|
constraintWidget.setFinalVertical(i3, i4);
|
|
verticalSolvingPass(constraintWidget, measurer);
|
|
}
|
|
|
|
private static void solveVerticalMatchConstraint(ConstraintWidget constraintWidget, BasicMeasure.Measurer measurer, ConstraintWidget constraintWidget2) {
|
|
float verticalBiasPercent = constraintWidget2.getVerticalBiasPercent();
|
|
int margin = constraintWidget2.mTop.getMargin() + constraintWidget2.mTop.mTarget.getFinalValue();
|
|
int finalValue = constraintWidget2.mBottom.mTarget.getFinalValue() - constraintWidget2.mBottom.getMargin();
|
|
if (finalValue >= margin) {
|
|
int height = constraintWidget2.getHeight();
|
|
if (constraintWidget2.getVisibility() != 8) {
|
|
int i = constraintWidget2.mMatchConstraintDefaultHeight;
|
|
if (i == 2) {
|
|
height = (int) (verticalBiasPercent * 0.5f * ((float) (constraintWidget instanceof ConstraintWidgetContainer ? constraintWidget.getHeight() : constraintWidget.getParent().getHeight())));
|
|
} else if (i == 0) {
|
|
height = finalValue - margin;
|
|
}
|
|
height = Math.max(constraintWidget2.mMatchConstraintMinHeight, height);
|
|
int i2 = constraintWidget2.mMatchConstraintMaxHeight;
|
|
if (i2 > 0) {
|
|
height = Math.min(i2, height);
|
|
}
|
|
}
|
|
int i3 = margin + ((int) ((verticalBiasPercent * ((float) ((finalValue - margin) - height))) + 0.5f));
|
|
constraintWidget2.setFinalVertical(i3, height + i3);
|
|
verticalSolvingPass(constraintWidget2, measurer);
|
|
}
|
|
}
|
|
|
|
public static void solvingPass(ConstraintWidgetContainer constraintWidgetContainer, BasicMeasure.Measurer measurer) {
|
|
ConstraintWidget.DimensionBehaviour horizontalDimensionBehaviour = constraintWidgetContainer.getHorizontalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour verticalDimensionBehaviour = constraintWidgetContainer.getVerticalDimensionBehaviour();
|
|
constraintWidgetContainer.resetFinalResolution();
|
|
ArrayList<ConstraintWidget> children = constraintWidgetContainer.getChildren();
|
|
int size = children.size();
|
|
for (int i = 0; i < size; i++) {
|
|
children.get(i).resetFinalResolution();
|
|
}
|
|
boolean isRtl = constraintWidgetContainer.isRtl();
|
|
if (horizontalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.FIXED) {
|
|
constraintWidgetContainer.setFinalHorizontal(0, constraintWidgetContainer.getWidth());
|
|
} else {
|
|
constraintWidgetContainer.setFinalLeft(0);
|
|
}
|
|
boolean z2 = false;
|
|
boolean z3 = false;
|
|
for (int i2 = 0; i2 < size; i2++) {
|
|
ConstraintWidget constraintWidget = children.get(i2);
|
|
if (constraintWidget instanceof Guideline) {
|
|
Guideline guideline = (Guideline) constraintWidget;
|
|
if (guideline.getOrientation() == 1) {
|
|
if (guideline.getRelativeBegin() != -1) {
|
|
guideline.setFinalValue(guideline.getRelativeBegin());
|
|
} else if (guideline.getRelativeEnd() != -1 && constraintWidgetContainer.isResolvedHorizontally()) {
|
|
guideline.setFinalValue(constraintWidgetContainer.getWidth() - guideline.getRelativeEnd());
|
|
} else if (constraintWidgetContainer.isResolvedHorizontally()) {
|
|
guideline.setFinalValue((int) ((guideline.getRelativePercent() * ((float) constraintWidgetContainer.getWidth())) + 0.5f));
|
|
}
|
|
z2 = true;
|
|
}
|
|
} else if ((constraintWidget instanceof Barrier) && ((Barrier) constraintWidget).getOrientation() == 0) {
|
|
z3 = true;
|
|
}
|
|
}
|
|
if (z2) {
|
|
for (int i3 = 0; i3 < size; i3++) {
|
|
ConstraintWidget constraintWidget2 = children.get(i3);
|
|
if (constraintWidget2 instanceof Guideline) {
|
|
Guideline guideline2 = (Guideline) constraintWidget2;
|
|
if (guideline2.getOrientation() == 1) {
|
|
horizontalSolvingPass(guideline2, measurer, isRtl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
horizontalSolvingPass(constraintWidgetContainer, measurer, isRtl);
|
|
if (z3) {
|
|
for (int i4 = 0; i4 < size; i4++) {
|
|
ConstraintWidget constraintWidget3 = children.get(i4);
|
|
if (constraintWidget3 instanceof Barrier) {
|
|
Barrier barrier = (Barrier) constraintWidget3;
|
|
if (barrier.getOrientation() == 0) {
|
|
solveBarrier(barrier, measurer, 0, isRtl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (verticalDimensionBehaviour == ConstraintWidget.DimensionBehaviour.FIXED) {
|
|
constraintWidgetContainer.setFinalVertical(0, constraintWidgetContainer.getHeight());
|
|
} else {
|
|
constraintWidgetContainer.setFinalTop(0);
|
|
}
|
|
boolean z4 = false;
|
|
boolean z5 = false;
|
|
for (int i5 = 0; i5 < size; i5++) {
|
|
ConstraintWidget constraintWidget4 = children.get(i5);
|
|
if (constraintWidget4 instanceof Guideline) {
|
|
Guideline guideline3 = (Guideline) constraintWidget4;
|
|
if (guideline3.getOrientation() == 0) {
|
|
if (guideline3.getRelativeBegin() != -1) {
|
|
guideline3.setFinalValue(guideline3.getRelativeBegin());
|
|
} else if (guideline3.getRelativeEnd() != -1 && constraintWidgetContainer.isResolvedVertically()) {
|
|
guideline3.setFinalValue(constraintWidgetContainer.getHeight() - guideline3.getRelativeEnd());
|
|
} else if (constraintWidgetContainer.isResolvedVertically()) {
|
|
guideline3.setFinalValue((int) ((guideline3.getRelativePercent() * ((float) constraintWidgetContainer.getHeight())) + 0.5f));
|
|
}
|
|
z4 = true;
|
|
}
|
|
} else if ((constraintWidget4 instanceof Barrier) && ((Barrier) constraintWidget4).getOrientation() == 1) {
|
|
z5 = true;
|
|
}
|
|
}
|
|
if (z4) {
|
|
for (int i6 = 0; i6 < size; i6++) {
|
|
ConstraintWidget constraintWidget5 = children.get(i6);
|
|
if (constraintWidget5 instanceof Guideline) {
|
|
Guideline guideline4 = (Guideline) constraintWidget5;
|
|
if (guideline4.getOrientation() == 0) {
|
|
verticalSolvingPass(guideline4, measurer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
verticalSolvingPass(constraintWidgetContainer, measurer);
|
|
if (z5) {
|
|
for (int i7 = 0; i7 < size; i7++) {
|
|
ConstraintWidget constraintWidget6 = children.get(i7);
|
|
if (constraintWidget6 instanceof Barrier) {
|
|
Barrier barrier2 = (Barrier) constraintWidget6;
|
|
if (barrier2.getOrientation() == 1) {
|
|
solveBarrier(barrier2, measurer, 1, isRtl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int i8 = 0; i8 < size; i8++) {
|
|
ConstraintWidget constraintWidget7 = children.get(i8);
|
|
if (constraintWidget7.isMeasureRequested() && canMeasure(constraintWidget7)) {
|
|
ConstraintWidgetContainer.measure(constraintWidget7, measurer, measure, BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
horizontalSolvingPass(constraintWidget7, measurer, isRtl);
|
|
verticalSolvingPass(constraintWidget7, measurer);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void verticalSolvingPass(ConstraintWidget constraintWidget, BasicMeasure.Measurer measurer) {
|
|
ConstraintAnchor constraintAnchor;
|
|
ConstraintAnchor constraintAnchor2;
|
|
ConstraintAnchor constraintAnchor3;
|
|
ConstraintAnchor constraintAnchor4;
|
|
ConstraintAnchor constraintAnchor5;
|
|
if (!(constraintWidget instanceof ConstraintWidgetContainer) && constraintWidget.isMeasureRequested() && canMeasure(constraintWidget)) {
|
|
ConstraintWidgetContainer.measure(constraintWidget, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
ConstraintAnchor anchor = constraintWidget.getAnchor(ConstraintAnchor.Type.TOP);
|
|
ConstraintAnchor anchor2 = constraintWidget.getAnchor(ConstraintAnchor.Type.BOTTOM);
|
|
int finalValue = anchor.getFinalValue();
|
|
int finalValue2 = anchor2.getFinalValue();
|
|
if (anchor.getDependents() != null && anchor.hasFinalValue()) {
|
|
Iterator<ConstraintAnchor> it = anchor.getDependents().iterator();
|
|
while (it.hasNext()) {
|
|
ConstraintAnchor next = it.next();
|
|
ConstraintWidget constraintWidget2 = next.mOwner;
|
|
boolean canMeasure = canMeasure(constraintWidget2);
|
|
if (constraintWidget2.isMeasureRequested() && canMeasure) {
|
|
ConstraintWidgetContainer.measure(constraintWidget2, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
ConstraintWidget.DimensionBehaviour verticalDimensionBehaviour = constraintWidget2.getVerticalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour = ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
|
|
if (verticalDimensionBehaviour != dimensionBehaviour || canMeasure) {
|
|
if (!constraintWidget2.isMeasureRequested()) {
|
|
ConstraintAnchor constraintAnchor6 = constraintWidget2.mTop;
|
|
if (next == constraintAnchor6 && constraintWidget2.mBottom.mTarget == null) {
|
|
int margin = constraintAnchor6.getMargin() + finalValue;
|
|
constraintWidget2.setFinalVertical(margin, constraintWidget2.getHeight() + margin);
|
|
verticalSolvingPass(constraintWidget2, measurer);
|
|
} else {
|
|
ConstraintAnchor constraintAnchor7 = constraintWidget2.mBottom;
|
|
if (next == constraintAnchor7 && constraintAnchor7.mTarget == null) {
|
|
int margin2 = finalValue - constraintAnchor7.getMargin();
|
|
constraintWidget2.setFinalVertical(margin2 - constraintWidget2.getHeight(), margin2);
|
|
verticalSolvingPass(constraintWidget2, measurer);
|
|
} else if (next == constraintAnchor6 && (constraintAnchor3 = constraintAnchor7.mTarget) != null && constraintAnchor3.hasFinalValue()) {
|
|
solveVerticalCenterConstraints(measurer, constraintWidget2);
|
|
}
|
|
}
|
|
}
|
|
} else if (constraintWidget2.getVerticalDimensionBehaviour() == dimensionBehaviour && constraintWidget2.mMatchConstraintMaxHeight >= 0 && constraintWidget2.mMatchConstraintMinHeight >= 0) {
|
|
if (constraintWidget2.getVisibility() == 8 || (constraintWidget2.mMatchConstraintDefaultHeight == 0 && constraintWidget2.getDimensionRatio() == 0.0f)) {
|
|
if (!constraintWidget2.isInVerticalChain() && !constraintWidget2.isInVirtualLayout()) {
|
|
if (((next == constraintWidget2.mTop && (constraintAnchor5 = constraintWidget2.mBottom.mTarget) != null && constraintAnchor5.hasFinalValue()) || (next == constraintWidget2.mBottom && (constraintAnchor4 = constraintWidget2.mTop.mTarget) != null && constraintAnchor4.hasFinalValue())) && !constraintWidget2.isInVerticalChain()) {
|
|
solveVerticalMatchConstraint(constraintWidget, measurer, constraintWidget2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!(constraintWidget instanceof Guideline)) {
|
|
if (anchor2.getDependents() != null && anchor2.hasFinalValue()) {
|
|
Iterator<ConstraintAnchor> it2 = anchor2.getDependents().iterator();
|
|
while (it2.hasNext()) {
|
|
ConstraintAnchor next2 = it2.next();
|
|
ConstraintWidget constraintWidget3 = next2.mOwner;
|
|
boolean canMeasure2 = canMeasure(constraintWidget3);
|
|
if (constraintWidget3.isMeasureRequested() && canMeasure2) {
|
|
ConstraintWidgetContainer.measure(constraintWidget3, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
boolean z2 = (next2 == constraintWidget3.mTop && (constraintAnchor2 = constraintWidget3.mBottom.mTarget) != null && constraintAnchor2.hasFinalValue()) || (next2 == constraintWidget3.mBottom && (constraintAnchor = constraintWidget3.mTop.mTarget) != null && constraintAnchor.hasFinalValue());
|
|
ConstraintWidget.DimensionBehaviour verticalDimensionBehaviour2 = constraintWidget3.getVerticalDimensionBehaviour();
|
|
ConstraintWidget.DimensionBehaviour dimensionBehaviour2 = ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT;
|
|
if (verticalDimensionBehaviour2 != dimensionBehaviour2 || canMeasure2) {
|
|
if (!constraintWidget3.isMeasureRequested()) {
|
|
ConstraintAnchor constraintAnchor8 = constraintWidget3.mTop;
|
|
if (next2 == constraintAnchor8 && constraintWidget3.mBottom.mTarget == null) {
|
|
int margin3 = constraintAnchor8.getMargin() + finalValue2;
|
|
constraintWidget3.setFinalVertical(margin3, constraintWidget3.getHeight() + margin3);
|
|
verticalSolvingPass(constraintWidget3, measurer);
|
|
} else {
|
|
ConstraintAnchor constraintAnchor9 = constraintWidget3.mBottom;
|
|
if (next2 == constraintAnchor9 && constraintAnchor8.mTarget == null) {
|
|
int margin4 = finalValue2 - constraintAnchor9.getMargin();
|
|
constraintWidget3.setFinalVertical(margin4 - constraintWidget3.getHeight(), margin4);
|
|
verticalSolvingPass(constraintWidget3, measurer);
|
|
} else if (z2 && !constraintWidget3.isInVerticalChain()) {
|
|
solveVerticalCenterConstraints(measurer, constraintWidget3);
|
|
}
|
|
}
|
|
}
|
|
} else if (constraintWidget3.getVerticalDimensionBehaviour() == dimensionBehaviour2 && constraintWidget3.mMatchConstraintMaxHeight >= 0 && constraintWidget3.mMatchConstraintMinHeight >= 0) {
|
|
if (constraintWidget3.getVisibility() == 8 || (constraintWidget3.mMatchConstraintDefaultHeight == 0 && constraintWidget3.getDimensionRatio() == 0.0f)) {
|
|
if (!constraintWidget3.isInVerticalChain() && !constraintWidget3.isInVirtualLayout() && z2 && !constraintWidget3.isInVerticalChain()) {
|
|
solveVerticalMatchConstraint(constraintWidget, measurer, constraintWidget3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ConstraintAnchor anchor3 = constraintWidget.getAnchor(ConstraintAnchor.Type.BASELINE);
|
|
if (anchor3.getDependents() != null && anchor3.hasFinalValue()) {
|
|
int finalValue3 = anchor3.getFinalValue();
|
|
Iterator<ConstraintAnchor> it3 = anchor3.getDependents().iterator();
|
|
while (it3.hasNext()) {
|
|
ConstraintAnchor next3 = it3.next();
|
|
ConstraintWidget constraintWidget4 = next3.mOwner;
|
|
boolean canMeasure3 = canMeasure(constraintWidget4);
|
|
if (constraintWidget4.isMeasureRequested() && canMeasure3) {
|
|
ConstraintWidgetContainer.measure(constraintWidget4, measurer, new BasicMeasure.Measure(), BasicMeasure.Measure.SELF_DIMENSIONS);
|
|
}
|
|
if (constraintWidget4.getVerticalDimensionBehaviour() != ConstraintWidget.DimensionBehaviour.MATCH_CONSTRAINT || canMeasure3) {
|
|
if (!constraintWidget4.isMeasureRequested() && next3 == constraintWidget4.mBaseline) {
|
|
constraintWidget4.setFinalBaseline(finalValue3);
|
|
verticalSolvingPass(constraintWidget4, measurer);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|