420 lines
14 KiB
Java
420 lines
14 KiB
Java
package androidx.constraintlayout.solver.widgets;
|
|
|
|
import androidx.constraintlayout.solver.Cache;
|
|
import androidx.constraintlayout.solver.SolverVariable;
|
|
import androidx.constraintlayout.solver.widgets.analyzer.Grouping;
|
|
import androidx.constraintlayout.solver.widgets.analyzer.WidgetGroup;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
public class ConstraintAnchor {
|
|
private static final boolean ALLOW_BINARY = false;
|
|
private static final int UNSET_GONE_MARGIN = -1;
|
|
private HashSet<ConstraintAnchor> mDependents = null;
|
|
private int mFinalValue;
|
|
public int mGoneMargin = -1;
|
|
private boolean mHasFinalValue;
|
|
public int mMargin = 0;
|
|
public final ConstraintWidget mOwner;
|
|
public SolverVariable mSolverVariable;
|
|
public ConstraintAnchor mTarget;
|
|
public final Type mType;
|
|
|
|
/* renamed from: androidx.constraintlayout.solver.widgets.ConstraintAnchor$1 reason: invalid class name */
|
|
public static /* synthetic */ class AnonymousClass1 {
|
|
public static final /* synthetic */ int[] $SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type;
|
|
|
|
static {
|
|
Type.values();
|
|
int[] iArr = new int[9];
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type = iArr;
|
|
try {
|
|
iArr[Type.CENTER.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.LEFT.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.RIGHT.ordinal()] = 3;
|
|
} catch (NoSuchFieldError unused3) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.TOP.ordinal()] = 4;
|
|
} catch (NoSuchFieldError unused4) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.BOTTOM.ordinal()] = 5;
|
|
} catch (NoSuchFieldError unused5) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.BASELINE.ordinal()] = 6;
|
|
} catch (NoSuchFieldError unused6) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.CENTER_X.ordinal()] = 7;
|
|
} catch (NoSuchFieldError unused7) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.CENTER_Y.ordinal()] = 8;
|
|
} catch (NoSuchFieldError unused8) {
|
|
}
|
|
try {
|
|
$SwitchMap$androidx$constraintlayout$solver$widgets$ConstraintAnchor$Type[Type.NONE.ordinal()] = 9;
|
|
} catch (NoSuchFieldError unused9) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum Type {
|
|
NONE,
|
|
LEFT,
|
|
TOP,
|
|
RIGHT,
|
|
BOTTOM,
|
|
BASELINE,
|
|
CENTER,
|
|
CENTER_X,
|
|
CENTER_Y
|
|
}
|
|
|
|
public ConstraintAnchor(ConstraintWidget constraintWidget, Type type) {
|
|
this.mOwner = constraintWidget;
|
|
this.mType = type;
|
|
}
|
|
|
|
private boolean isConnectionToMe(ConstraintWidget constraintWidget, HashSet<ConstraintWidget> hashSet) {
|
|
if (hashSet.contains(constraintWidget)) {
|
|
return false;
|
|
}
|
|
hashSet.add(constraintWidget);
|
|
if (constraintWidget == getOwner()) {
|
|
return true;
|
|
}
|
|
ArrayList<ConstraintAnchor> anchors = constraintWidget.getAnchors();
|
|
int size = anchors.size();
|
|
for (int i = 0; i < size; i++) {
|
|
ConstraintAnchor constraintAnchor = anchors.get(i);
|
|
if (constraintAnchor.isSimilarDimensionConnection(this) && constraintAnchor.isConnected() && isConnectionToMe(constraintAnchor.getTarget().getOwner(), hashSet)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean connect(ConstraintAnchor constraintAnchor, int i) {
|
|
return connect(constraintAnchor, i, -1, false);
|
|
}
|
|
|
|
public boolean connect(ConstraintAnchor constraintAnchor, int i, int i2, boolean z2) {
|
|
if (constraintAnchor == null) {
|
|
reset();
|
|
return true;
|
|
} else if (!z2 && !isValidConnection(constraintAnchor)) {
|
|
return false;
|
|
} else {
|
|
this.mTarget = constraintAnchor;
|
|
if (constraintAnchor.mDependents == null) {
|
|
constraintAnchor.mDependents = new HashSet<>();
|
|
}
|
|
HashSet<ConstraintAnchor> hashSet = this.mTarget.mDependents;
|
|
if (hashSet != null) {
|
|
hashSet.add(this);
|
|
}
|
|
if (i > 0) {
|
|
this.mMargin = i;
|
|
} else {
|
|
this.mMargin = 0;
|
|
}
|
|
this.mGoneMargin = i2;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public void copyFrom(ConstraintAnchor constraintAnchor, HashMap<ConstraintWidget, ConstraintWidget> hashMap) {
|
|
HashSet<ConstraintAnchor> hashSet;
|
|
ConstraintAnchor constraintAnchor2 = this.mTarget;
|
|
if (!(constraintAnchor2 == null || (hashSet = constraintAnchor2.mDependents) == null)) {
|
|
hashSet.remove(this);
|
|
}
|
|
ConstraintAnchor constraintAnchor3 = constraintAnchor.mTarget;
|
|
if (constraintAnchor3 != null) {
|
|
this.mTarget = hashMap.get(constraintAnchor.mTarget.mOwner).getAnchor(constraintAnchor3.getType());
|
|
} else {
|
|
this.mTarget = null;
|
|
}
|
|
ConstraintAnchor constraintAnchor4 = this.mTarget;
|
|
if (constraintAnchor4 != null) {
|
|
if (constraintAnchor4.mDependents == null) {
|
|
constraintAnchor4.mDependents = new HashSet<>();
|
|
}
|
|
this.mTarget.mDependents.add(this);
|
|
}
|
|
this.mMargin = constraintAnchor.mMargin;
|
|
this.mGoneMargin = constraintAnchor.mGoneMargin;
|
|
}
|
|
|
|
public void findDependents(int i, ArrayList<WidgetGroup> arrayList, WidgetGroup widgetGroup) {
|
|
HashSet<ConstraintAnchor> hashSet = this.mDependents;
|
|
if (hashSet != null) {
|
|
Iterator<ConstraintAnchor> it = hashSet.iterator();
|
|
while (it.hasNext()) {
|
|
Grouping.findDependents(it.next().mOwner, i, arrayList, widgetGroup);
|
|
}
|
|
}
|
|
}
|
|
|
|
public HashSet<ConstraintAnchor> getDependents() {
|
|
return this.mDependents;
|
|
}
|
|
|
|
public int getFinalValue() {
|
|
if (!this.mHasFinalValue) {
|
|
return 0;
|
|
}
|
|
return this.mFinalValue;
|
|
}
|
|
|
|
public int getMargin() {
|
|
ConstraintAnchor constraintAnchor;
|
|
if (this.mOwner.getVisibility() == 8) {
|
|
return 0;
|
|
}
|
|
return (this.mGoneMargin <= -1 || (constraintAnchor = this.mTarget) == null || constraintAnchor.mOwner.getVisibility() != 8) ? this.mMargin : this.mGoneMargin;
|
|
}
|
|
|
|
public final ConstraintAnchor getOpposite() {
|
|
switch (this.mType.ordinal()) {
|
|
case 0:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
return null;
|
|
case 1:
|
|
return this.mOwner.mRight;
|
|
case 2:
|
|
return this.mOwner.mBottom;
|
|
case 3:
|
|
return this.mOwner.mLeft;
|
|
case 4:
|
|
return this.mOwner.mTop;
|
|
default:
|
|
throw new AssertionError(this.mType.name());
|
|
}
|
|
}
|
|
|
|
public ConstraintWidget getOwner() {
|
|
return this.mOwner;
|
|
}
|
|
|
|
public SolverVariable getSolverVariable() {
|
|
return this.mSolverVariable;
|
|
}
|
|
|
|
public ConstraintAnchor getTarget() {
|
|
return this.mTarget;
|
|
}
|
|
|
|
public Type getType() {
|
|
return this.mType;
|
|
}
|
|
|
|
public boolean hasCenteredDependents() {
|
|
HashSet<ConstraintAnchor> hashSet = this.mDependents;
|
|
if (hashSet == null) {
|
|
return false;
|
|
}
|
|
Iterator<ConstraintAnchor> it = hashSet.iterator();
|
|
while (it.hasNext()) {
|
|
if (it.next().getOpposite().isConnected()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public boolean hasDependents() {
|
|
HashSet<ConstraintAnchor> hashSet = this.mDependents;
|
|
return hashSet != null && hashSet.size() > 0;
|
|
}
|
|
|
|
public boolean hasFinalValue() {
|
|
return this.mHasFinalValue;
|
|
}
|
|
|
|
public boolean isConnected() {
|
|
return this.mTarget != null;
|
|
}
|
|
|
|
public boolean isConnectionAllowed(ConstraintWidget constraintWidget) {
|
|
if (isConnectionToMe(constraintWidget, new HashSet<>())) {
|
|
return false;
|
|
}
|
|
ConstraintWidget parent = getOwner().getParent();
|
|
return parent == constraintWidget || constraintWidget.getParent() == parent;
|
|
}
|
|
|
|
public boolean isConnectionAllowed(ConstraintWidget constraintWidget, ConstraintAnchor constraintAnchor) {
|
|
return isConnectionAllowed(constraintWidget);
|
|
}
|
|
|
|
public boolean isSideAnchor() {
|
|
switch (this.mType.ordinal()) {
|
|
case 0:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
return false;
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
return true;
|
|
default:
|
|
throw new AssertionError(this.mType.name());
|
|
}
|
|
}
|
|
|
|
public boolean isSimilarDimensionConnection(ConstraintAnchor constraintAnchor) {
|
|
Type type = constraintAnchor.getType();
|
|
Type type2 = this.mType;
|
|
if (type == type2) {
|
|
return true;
|
|
}
|
|
switch (type2.ordinal()) {
|
|
case 0:
|
|
return false;
|
|
case 1:
|
|
case 3:
|
|
case 7:
|
|
return type == Type.LEFT || type == Type.RIGHT || type == Type.CENTER_X;
|
|
case 2:
|
|
case 4:
|
|
case 5:
|
|
case 8:
|
|
return type == Type.TOP || type == Type.BOTTOM || type == Type.CENTER_Y || type == Type.BASELINE;
|
|
case 6:
|
|
return type != Type.BASELINE;
|
|
default:
|
|
throw new AssertionError(this.mType.name());
|
|
}
|
|
}
|
|
|
|
public boolean isValidConnection(ConstraintAnchor constraintAnchor) {
|
|
boolean z2 = false;
|
|
if (constraintAnchor == null) {
|
|
return false;
|
|
}
|
|
Type type = constraintAnchor.getType();
|
|
Type type2 = this.mType;
|
|
if (type == type2) {
|
|
return type2 != Type.BASELINE || (constraintAnchor.getOwner().hasBaseline() && getOwner().hasBaseline());
|
|
}
|
|
switch (type2.ordinal()) {
|
|
case 0:
|
|
case 5:
|
|
case 7:
|
|
case 8:
|
|
return false;
|
|
case 1:
|
|
case 3:
|
|
boolean z3 = type == Type.LEFT || type == Type.RIGHT;
|
|
if (!(constraintAnchor.getOwner() instanceof Guideline)) {
|
|
return z3;
|
|
}
|
|
if (z3 || type == Type.CENTER_X) {
|
|
z2 = true;
|
|
}
|
|
return z2;
|
|
case 2:
|
|
case 4:
|
|
boolean z4 = type == Type.TOP || type == Type.BOTTOM;
|
|
if (!(constraintAnchor.getOwner() instanceof Guideline)) {
|
|
return z4;
|
|
}
|
|
if (z4 || type == Type.CENTER_Y) {
|
|
z2 = true;
|
|
}
|
|
return z2;
|
|
case 6:
|
|
return (type == Type.BASELINE || type == Type.CENTER_X || type == Type.CENTER_Y) ? false : true;
|
|
default:
|
|
throw new AssertionError(this.mType.name());
|
|
}
|
|
}
|
|
|
|
public boolean isVerticalAnchor() {
|
|
switch (this.mType.ordinal()) {
|
|
case 0:
|
|
case 2:
|
|
case 4:
|
|
case 5:
|
|
case 8:
|
|
return true;
|
|
case 1:
|
|
case 3:
|
|
case 6:
|
|
case 7:
|
|
return false;
|
|
default:
|
|
throw new AssertionError(this.mType.name());
|
|
}
|
|
}
|
|
|
|
public void reset() {
|
|
HashSet<ConstraintAnchor> hashSet;
|
|
ConstraintAnchor constraintAnchor = this.mTarget;
|
|
if (!(constraintAnchor == null || (hashSet = constraintAnchor.mDependents) == null)) {
|
|
hashSet.remove(this);
|
|
if (this.mTarget.mDependents.size() == 0) {
|
|
this.mTarget.mDependents = null;
|
|
}
|
|
}
|
|
this.mDependents = null;
|
|
this.mTarget = null;
|
|
this.mMargin = 0;
|
|
this.mGoneMargin = -1;
|
|
this.mHasFinalValue = false;
|
|
this.mFinalValue = 0;
|
|
}
|
|
|
|
public void resetFinalResolution() {
|
|
this.mHasFinalValue = false;
|
|
this.mFinalValue = 0;
|
|
}
|
|
|
|
public void resetSolverVariable(Cache cache) {
|
|
SolverVariable solverVariable = this.mSolverVariable;
|
|
if (solverVariable == null) {
|
|
this.mSolverVariable = new SolverVariable(SolverVariable.Type.UNRESTRICTED, (String) null);
|
|
} else {
|
|
solverVariable.reset();
|
|
}
|
|
}
|
|
|
|
public void setFinalValue(int i) {
|
|
this.mFinalValue = i;
|
|
this.mHasFinalValue = true;
|
|
}
|
|
|
|
public void setGoneMargin(int i) {
|
|
if (isConnected()) {
|
|
this.mGoneMargin = i;
|
|
}
|
|
}
|
|
|
|
public void setMargin(int i) {
|
|
if (isConnected()) {
|
|
this.mMargin = i;
|
|
}
|
|
}
|
|
|
|
public String toString() {
|
|
return this.mOwner.getDebugName() + ":" + this.mType.toString();
|
|
}
|
|
}
|