3095 lines
146 KiB
Java
3095 lines
146 KiB
Java
package androidx.constraintlayout.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.TypedArray;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.graphics.Color;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.util.SparseIntArray;
|
|
import android.util.Xml;
|
|
import android.view.LayoutInflater;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import androidx.constraintlayout.motion.utils.Easing;
|
|
import androidx.constraintlayout.motion.widget.Debug;
|
|
import androidx.constraintlayout.motion.widget.MotionScene;
|
|
import androidx.constraintlayout.solver.widgets.ConstraintWidget;
|
|
import androidx.constraintlayout.solver.widgets.HelperWidget;
|
|
import androidx.constraintlayout.widget.ConstraintAttribute;
|
|
import androidx.constraintlayout.widget.ConstraintLayout;
|
|
import androidx.constraintlayout.widget.Constraints;
|
|
import androidx.constraintlayout.widget.R;
|
|
import c.d.b.a.a;
|
|
import com.discord.models.domain.ModelAuditLogEntry;
|
|
import com.google.android.material.shadow.ShadowDrawableWrapper;
|
|
import java.io.IOException;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Modifier;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Set;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
public class ConstraintSet {
|
|
private static final int ALPHA = 43;
|
|
private static final int ANIMATE_RELATIVE_TO = 64;
|
|
private static final int BARRIER_ALLOWS_GONE_WIDGETS = 75;
|
|
private static final int BARRIER_DIRECTION = 72;
|
|
private static final int BARRIER_MARGIN = 73;
|
|
private static final int BARRIER_TYPE = 1;
|
|
public static final int BASELINE = 5;
|
|
private static final int BASELINE_TO_BASELINE = 1;
|
|
public static final int BOTTOM = 4;
|
|
private static final int BOTTOM_MARGIN = 2;
|
|
private static final int BOTTOM_TO_BOTTOM = 3;
|
|
private static final int BOTTOM_TO_TOP = 4;
|
|
public static final int CHAIN_PACKED = 2;
|
|
public static final int CHAIN_SPREAD = 0;
|
|
public static final int CHAIN_SPREAD_INSIDE = 1;
|
|
private static final int CHAIN_USE_RTL = 71;
|
|
private static final int CIRCLE = 61;
|
|
private static final int CIRCLE_ANGLE = 63;
|
|
private static final int CIRCLE_RADIUS = 62;
|
|
private static final int CONSTRAINED_HEIGHT = 81;
|
|
private static final int CONSTRAINED_WIDTH = 80;
|
|
private static final int CONSTRAINT_REFERENCED_IDS = 74;
|
|
private static final int CONSTRAINT_TAG = 77;
|
|
private static final boolean DEBUG = false;
|
|
private static final int DIMENSION_RATIO = 5;
|
|
private static final int DRAW_PATH = 66;
|
|
private static final int EDITOR_ABSOLUTE_X = 6;
|
|
private static final int EDITOR_ABSOLUTE_Y = 7;
|
|
private static final int ELEVATION = 44;
|
|
public static final int END = 7;
|
|
private static final int END_MARGIN = 8;
|
|
private static final int END_TO_END = 9;
|
|
private static final int END_TO_START = 10;
|
|
private static final String ERROR_MESSAGE = "XML parser error must be within a Constraint ";
|
|
public static final int GONE = 8;
|
|
private static final int GONE_BOTTOM_MARGIN = 11;
|
|
private static final int GONE_END_MARGIN = 12;
|
|
private static final int GONE_LEFT_MARGIN = 13;
|
|
private static final int GONE_RIGHT_MARGIN = 14;
|
|
private static final int GONE_START_MARGIN = 15;
|
|
private static final int GONE_TOP_MARGIN = 16;
|
|
private static final int GUIDE_BEGIN = 17;
|
|
private static final int GUIDE_END = 18;
|
|
private static final int GUIDE_PERCENT = 19;
|
|
private static final int HEIGHT_DEFAULT = 55;
|
|
private static final int HEIGHT_MAX = 57;
|
|
private static final int HEIGHT_MIN = 59;
|
|
private static final int HEIGHT_PERCENT = 70;
|
|
public static final int HORIZONTAL = 0;
|
|
private static final int HORIZONTAL_BIAS = 20;
|
|
public static final int HORIZONTAL_GUIDELINE = 0;
|
|
private static final int HORIZONTAL_STYLE = 41;
|
|
private static final int HORIZONTAL_WEIGHT = 39;
|
|
public static final int INVISIBLE = 4;
|
|
private static final int LAYOUT_HEIGHT = 21;
|
|
private static final int LAYOUT_VISIBILITY = 22;
|
|
private static final int LAYOUT_WIDTH = 23;
|
|
public static final int LEFT = 1;
|
|
private static final int LEFT_MARGIN = 24;
|
|
private static final int LEFT_TO_LEFT = 25;
|
|
private static final int LEFT_TO_RIGHT = 26;
|
|
public static final int MATCH_CONSTRAINT = 0;
|
|
public static final int MATCH_CONSTRAINT_SPREAD = 0;
|
|
public static final int MATCH_CONSTRAINT_WRAP = 1;
|
|
private static final int MOTION_STAGGER = 79;
|
|
private static final int ORIENTATION = 27;
|
|
public static final int PARENT_ID = 0;
|
|
private static final int PATH_MOTION_ARC = 76;
|
|
private static final int PROGRESS = 68;
|
|
public static final int RIGHT = 2;
|
|
private static final int RIGHT_MARGIN = 28;
|
|
private static final int RIGHT_TO_LEFT = 29;
|
|
private static final int RIGHT_TO_RIGHT = 30;
|
|
private static final int ROTATION = 60;
|
|
private static final int ROTATION_X = 45;
|
|
private static final int ROTATION_Y = 46;
|
|
private static final int SCALE_X = 47;
|
|
private static final int SCALE_Y = 48;
|
|
public static final int START = 6;
|
|
private static final int START_MARGIN = 31;
|
|
private static final int START_TO_END = 32;
|
|
private static final int START_TO_START = 33;
|
|
private static final String TAG = "ConstraintSet";
|
|
public static final int TOP = 3;
|
|
private static final int TOP_MARGIN = 34;
|
|
private static final int TOP_TO_BOTTOM = 35;
|
|
private static final int TOP_TO_TOP = 36;
|
|
private static final int TRANSFORM_PIVOT_X = 49;
|
|
private static final int TRANSFORM_PIVOT_Y = 50;
|
|
private static final int TRANSITION_EASING = 65;
|
|
private static final int TRANSITION_PATH_ROTATE = 67;
|
|
private static final int TRANSLATION_X = 51;
|
|
private static final int TRANSLATION_Y = 52;
|
|
private static final int TRANSLATION_Z = 53;
|
|
public static final int UNSET = -1;
|
|
private static final int UNUSED = 82;
|
|
public static final int VERTICAL = 1;
|
|
private static final int VERTICAL_BIAS = 37;
|
|
public static final int VERTICAL_GUIDELINE = 1;
|
|
private static final int VERTICAL_STYLE = 42;
|
|
private static final int VERTICAL_WEIGHT = 40;
|
|
private static final int VIEW_ID = 38;
|
|
private static final int[] VISIBILITY_FLAGS = {0, 4, 8};
|
|
private static final int VISIBILITY_MODE = 78;
|
|
public static final int VISIBILITY_MODE_IGNORE = 1;
|
|
public static final int VISIBILITY_MODE_NORMAL = 0;
|
|
public static final int VISIBLE = 0;
|
|
private static final int WIDTH_DEFAULT = 54;
|
|
private static final int WIDTH_MAX = 56;
|
|
private static final int WIDTH_MIN = 58;
|
|
private static final int WIDTH_PERCENT = 69;
|
|
public static final int WRAP_CONTENT = -2;
|
|
private static SparseIntArray mapToConstant;
|
|
private HashMap<Integer, Constraint> mConstraints = new HashMap<>();
|
|
private boolean mForceId = true;
|
|
private HashMap<String, ConstraintAttribute> mSavedAttributes = new HashMap<>();
|
|
private boolean mValidate;
|
|
|
|
public static class Constraint {
|
|
public final Layout layout = new Layout();
|
|
public HashMap<String, ConstraintAttribute> mCustomConstraints = new HashMap<>();
|
|
public int mViewId;
|
|
public final Motion motion = new Motion();
|
|
public final PropertySet propertySet = new PropertySet();
|
|
public final Transform transform = new Transform();
|
|
|
|
public static /* synthetic */ void access$000(Constraint constraint, int i, ConstraintLayout.LayoutParams layoutParams) {
|
|
constraint.fillFrom(i, layoutParams);
|
|
}
|
|
|
|
public static /* synthetic */ void access$300(Constraint constraint, ConstraintHelper constraintHelper, int i, Constraints.LayoutParams layoutParams) {
|
|
constraint.fillFromConstraints(constraintHelper, i, layoutParams);
|
|
}
|
|
|
|
public static /* synthetic */ void access$400(Constraint constraint, int i, Constraints.LayoutParams layoutParams) {
|
|
constraint.fillFromConstraints(i, layoutParams);
|
|
}
|
|
|
|
public static /* synthetic */ void access$500(Constraint constraint, String str, int i) {
|
|
constraint.setIntValue(str, i);
|
|
}
|
|
|
|
public static /* synthetic */ void access$600(Constraint constraint, String str, int i) {
|
|
constraint.setColorValue(str, i);
|
|
}
|
|
|
|
public static /* synthetic */ void access$700(Constraint constraint, String str, float f) {
|
|
constraint.setFloatValue(str, f);
|
|
}
|
|
|
|
public static /* synthetic */ void access$800(Constraint constraint, String str, String str2) {
|
|
constraint.setStringValue(str, str2);
|
|
}
|
|
|
|
private void fillFrom(int i, ConstraintLayout.LayoutParams layoutParams) {
|
|
this.mViewId = i;
|
|
Layout layout = this.layout;
|
|
layout.leftToLeft = layoutParams.leftToLeft;
|
|
layout.leftToRight = layoutParams.leftToRight;
|
|
layout.rightToLeft = layoutParams.rightToLeft;
|
|
layout.rightToRight = layoutParams.rightToRight;
|
|
layout.topToTop = layoutParams.topToTop;
|
|
layout.topToBottom = layoutParams.topToBottom;
|
|
layout.bottomToTop = layoutParams.bottomToTop;
|
|
layout.bottomToBottom = layoutParams.bottomToBottom;
|
|
layout.baselineToBaseline = layoutParams.baselineToBaseline;
|
|
layout.startToEnd = layoutParams.startToEnd;
|
|
layout.startToStart = layoutParams.startToStart;
|
|
layout.endToStart = layoutParams.endToStart;
|
|
layout.endToEnd = layoutParams.endToEnd;
|
|
layout.horizontalBias = layoutParams.horizontalBias;
|
|
layout.verticalBias = layoutParams.verticalBias;
|
|
layout.dimensionRatio = layoutParams.dimensionRatio;
|
|
layout.circleConstraint = layoutParams.circleConstraint;
|
|
layout.circleRadius = layoutParams.circleRadius;
|
|
layout.circleAngle = layoutParams.circleAngle;
|
|
layout.editorAbsoluteX = layoutParams.editorAbsoluteX;
|
|
layout.editorAbsoluteY = layoutParams.editorAbsoluteY;
|
|
layout.orientation = layoutParams.orientation;
|
|
layout.guidePercent = layoutParams.guidePercent;
|
|
layout.guideBegin = layoutParams.guideBegin;
|
|
layout.guideEnd = layoutParams.guideEnd;
|
|
Layout layout2 = this.layout;
|
|
layout2.mWidth = ((ViewGroup.MarginLayoutParams) layoutParams).width;
|
|
layout2.mHeight = ((ViewGroup.MarginLayoutParams) layoutParams).height;
|
|
layout2.leftMargin = ((ViewGroup.MarginLayoutParams) layoutParams).leftMargin;
|
|
layout2.rightMargin = ((ViewGroup.MarginLayoutParams) layoutParams).rightMargin;
|
|
layout2.topMargin = ((ViewGroup.MarginLayoutParams) layoutParams).topMargin;
|
|
layout2.bottomMargin = ((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin;
|
|
layout2.verticalWeight = layoutParams.verticalWeight;
|
|
layout2.horizontalWeight = layoutParams.horizontalWeight;
|
|
layout2.verticalChainStyle = layoutParams.verticalChainStyle;
|
|
layout2.horizontalChainStyle = layoutParams.horizontalChainStyle;
|
|
layout2.constrainedWidth = layoutParams.constrainedWidth;
|
|
layout2.constrainedHeight = layoutParams.constrainedHeight;
|
|
layout2.widthDefault = layoutParams.matchConstraintDefaultWidth;
|
|
layout2.heightDefault = layoutParams.matchConstraintDefaultHeight;
|
|
layout2.widthMax = layoutParams.matchConstraintMaxWidth;
|
|
layout2.heightMax = layoutParams.matchConstraintMaxHeight;
|
|
layout2.widthMin = layoutParams.matchConstraintMinWidth;
|
|
layout2.heightMin = layoutParams.matchConstraintMinHeight;
|
|
layout2.widthPercent = layoutParams.matchConstraintPercentWidth;
|
|
layout2.heightPercent = layoutParams.matchConstraintPercentHeight;
|
|
layout2.mConstraintTag = layoutParams.constraintTag;
|
|
layout2.goneTopMargin = layoutParams.goneTopMargin;
|
|
layout2.goneBottomMargin = layoutParams.goneBottomMargin;
|
|
layout2.goneLeftMargin = layoutParams.goneLeftMargin;
|
|
layout2.goneRightMargin = layoutParams.goneRightMargin;
|
|
Layout layout3 = this.layout;
|
|
layout3.goneStartMargin = layoutParams.goneStartMargin;
|
|
layout3.goneEndMargin = layoutParams.goneEndMargin;
|
|
layout3.endMargin = layoutParams.getMarginEnd();
|
|
this.layout.startMargin = layoutParams.getMarginStart();
|
|
}
|
|
|
|
private void fillFromConstraints(int i, Constraints.LayoutParams layoutParams) {
|
|
fillFrom(i, layoutParams);
|
|
this.propertySet.alpha = layoutParams.alpha;
|
|
Transform transform = this.transform;
|
|
transform.rotation = layoutParams.rotation;
|
|
transform.rotationX = layoutParams.rotationX;
|
|
transform.rotationY = layoutParams.rotationY;
|
|
transform.scaleX = layoutParams.scaleX;
|
|
transform.scaleY = layoutParams.scaleY;
|
|
transform.transformPivotX = layoutParams.transformPivotX;
|
|
transform.transformPivotY = layoutParams.transformPivotY;
|
|
transform.translationX = layoutParams.translationX;
|
|
transform.translationY = layoutParams.translationY;
|
|
transform.translationZ = layoutParams.translationZ;
|
|
transform.elevation = layoutParams.elevation;
|
|
transform.applyElevation = layoutParams.applyElevation;
|
|
}
|
|
|
|
private void fillFromConstraints(ConstraintHelper constraintHelper, int i, Constraints.LayoutParams layoutParams) {
|
|
fillFromConstraints(i, layoutParams);
|
|
if (constraintHelper instanceof Barrier) {
|
|
Layout layout = this.layout;
|
|
layout.mHelperType = 1;
|
|
Barrier barrier = (Barrier) constraintHelper;
|
|
layout.mBarrierDirection = barrier.getType();
|
|
this.layout.mReferenceIds = barrier.getReferencedIds();
|
|
this.layout.mBarrierMargin = barrier.getMargin();
|
|
}
|
|
}
|
|
|
|
private ConstraintAttribute get(String str, ConstraintAttribute.AttributeType attributeType) {
|
|
if (this.mCustomConstraints.containsKey(str)) {
|
|
ConstraintAttribute constraintAttribute = this.mCustomConstraints.get(str);
|
|
if (constraintAttribute.getType() == attributeType) {
|
|
return constraintAttribute;
|
|
}
|
|
StringBuilder L = a.L("ConstraintAttribute is already a ");
|
|
L.append(constraintAttribute.getType().name());
|
|
throw new IllegalArgumentException(L.toString());
|
|
}
|
|
ConstraintAttribute constraintAttribute2 = new ConstraintAttribute(str, attributeType);
|
|
this.mCustomConstraints.put(str, constraintAttribute2);
|
|
return constraintAttribute2;
|
|
}
|
|
|
|
private void setColorValue(String str, int i) {
|
|
get(str, ConstraintAttribute.AttributeType.COLOR_TYPE).setColorValue(i);
|
|
}
|
|
|
|
private void setFloatValue(String str, float f) {
|
|
get(str, ConstraintAttribute.AttributeType.FLOAT_TYPE).setFloatValue(f);
|
|
}
|
|
|
|
private void setIntValue(String str, int i) {
|
|
get(str, ConstraintAttribute.AttributeType.INT_TYPE).setIntValue(i);
|
|
}
|
|
|
|
private void setStringValue(String str, String str2) {
|
|
get(str, ConstraintAttribute.AttributeType.STRING_TYPE).setStringValue(str2);
|
|
}
|
|
|
|
public void applyTo(ConstraintLayout.LayoutParams layoutParams) {
|
|
Layout layout = this.layout;
|
|
layoutParams.leftToLeft = layout.leftToLeft;
|
|
layoutParams.leftToRight = layout.leftToRight;
|
|
layoutParams.rightToLeft = layout.rightToLeft;
|
|
layoutParams.rightToRight = layout.rightToRight;
|
|
layoutParams.topToTop = layout.topToTop;
|
|
layoutParams.topToBottom = layout.topToBottom;
|
|
layoutParams.bottomToTop = layout.bottomToTop;
|
|
layoutParams.bottomToBottom = layout.bottomToBottom;
|
|
layoutParams.baselineToBaseline = layout.baselineToBaseline;
|
|
layoutParams.startToEnd = layout.startToEnd;
|
|
layoutParams.startToStart = layout.startToStart;
|
|
layoutParams.endToStart = layout.endToStart;
|
|
layoutParams.endToEnd = layout.endToEnd;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).leftMargin = layout.leftMargin;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).rightMargin = layout.rightMargin;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).topMargin = layout.topMargin;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).bottomMargin = layout.bottomMargin;
|
|
layoutParams.goneStartMargin = layout.goneStartMargin;
|
|
layoutParams.goneEndMargin = layout.goneEndMargin;
|
|
layoutParams.goneTopMargin = layout.goneTopMargin;
|
|
layoutParams.goneBottomMargin = layout.goneBottomMargin;
|
|
layoutParams.horizontalBias = layout.horizontalBias;
|
|
layoutParams.verticalBias = layout.verticalBias;
|
|
layoutParams.circleConstraint = layout.circleConstraint;
|
|
layoutParams.circleRadius = layout.circleRadius;
|
|
Layout layout2 = this.layout;
|
|
layoutParams.circleAngle = layout2.circleAngle;
|
|
layoutParams.dimensionRatio = layout2.dimensionRatio;
|
|
layoutParams.editorAbsoluteX = layout2.editorAbsoluteX;
|
|
layoutParams.editorAbsoluteY = layout2.editorAbsoluteY;
|
|
layoutParams.verticalWeight = layout2.verticalWeight;
|
|
layoutParams.horizontalWeight = layout2.horizontalWeight;
|
|
layoutParams.verticalChainStyle = layout2.verticalChainStyle;
|
|
layoutParams.horizontalChainStyle = layout2.horizontalChainStyle;
|
|
layoutParams.constrainedWidth = layout2.constrainedWidth;
|
|
layoutParams.constrainedHeight = layout2.constrainedHeight;
|
|
layoutParams.matchConstraintDefaultWidth = layout2.widthDefault;
|
|
layoutParams.matchConstraintDefaultHeight = layout2.heightDefault;
|
|
layoutParams.matchConstraintMaxWidth = layout2.widthMax;
|
|
layoutParams.matchConstraintMaxHeight = layout2.heightMax;
|
|
layoutParams.matchConstraintMinWidth = layout2.widthMin;
|
|
layoutParams.matchConstraintMinHeight = layout2.heightMin;
|
|
layoutParams.matchConstraintPercentWidth = layout2.widthPercent;
|
|
layoutParams.matchConstraintPercentHeight = layout2.heightPercent;
|
|
layoutParams.orientation = layout2.orientation;
|
|
layoutParams.guidePercent = layout2.guidePercent;
|
|
layoutParams.guideBegin = layout2.guideBegin;
|
|
layoutParams.guideEnd = layout2.guideEnd;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).width = layout2.mWidth;
|
|
((ViewGroup.MarginLayoutParams) layoutParams).height = layout2.mHeight;
|
|
String str = layout2.mConstraintTag;
|
|
if (str != null) {
|
|
layoutParams.constraintTag = str;
|
|
}
|
|
layoutParams.setMarginStart(this.layout.startMargin);
|
|
layoutParams.setMarginEnd(this.layout.endMargin);
|
|
layoutParams.validate();
|
|
}
|
|
|
|
public Constraint clone() {
|
|
Constraint constraint = new Constraint();
|
|
constraint.layout.copyFrom(this.layout);
|
|
constraint.motion.copyFrom(this.motion);
|
|
constraint.propertySet.copyFrom(this.propertySet);
|
|
constraint.transform.copyFrom(this.transform);
|
|
constraint.mViewId = this.mViewId;
|
|
return constraint;
|
|
}
|
|
}
|
|
|
|
public static class Layout {
|
|
private static final int BARRIER_ALLOWS_GONE_WIDGETS = 75;
|
|
private static final int BARRIER_DIRECTION = 72;
|
|
private static final int BARRIER_MARGIN = 73;
|
|
private static final int BASELINE_TO_BASELINE = 1;
|
|
private static final int BOTTOM_MARGIN = 2;
|
|
private static final int BOTTOM_TO_BOTTOM = 3;
|
|
private static final int BOTTOM_TO_TOP = 4;
|
|
private static final int CHAIN_USE_RTL = 71;
|
|
private static final int CIRCLE = 61;
|
|
private static final int CIRCLE_ANGLE = 63;
|
|
private static final int CIRCLE_RADIUS = 62;
|
|
private static final int CONSTRAINT_REFERENCED_IDS = 74;
|
|
private static final int DIMENSION_RATIO = 5;
|
|
private static final int EDITOR_ABSOLUTE_X = 6;
|
|
private static final int EDITOR_ABSOLUTE_Y = 7;
|
|
private static final int END_MARGIN = 8;
|
|
private static final int END_TO_END = 9;
|
|
private static final int END_TO_START = 10;
|
|
private static final int GONE_BOTTOM_MARGIN = 11;
|
|
private static final int GONE_END_MARGIN = 12;
|
|
private static final int GONE_LEFT_MARGIN = 13;
|
|
private static final int GONE_RIGHT_MARGIN = 14;
|
|
private static final int GONE_START_MARGIN = 15;
|
|
private static final int GONE_TOP_MARGIN = 16;
|
|
private static final int GUIDE_BEGIN = 17;
|
|
private static final int GUIDE_END = 18;
|
|
private static final int GUIDE_PERCENT = 19;
|
|
private static final int HEIGHT_PERCENT = 70;
|
|
private static final int HORIZONTAL_BIAS = 20;
|
|
private static final int HORIZONTAL_STYLE = 39;
|
|
private static final int HORIZONTAL_WEIGHT = 37;
|
|
private static final int LAYOUT_HEIGHT = 21;
|
|
private static final int LAYOUT_WIDTH = 22;
|
|
private static final int LEFT_MARGIN = 23;
|
|
private static final int LEFT_TO_LEFT = 24;
|
|
private static final int LEFT_TO_RIGHT = 25;
|
|
private static final int ORIENTATION = 26;
|
|
private static final int RIGHT_MARGIN = 27;
|
|
private static final int RIGHT_TO_LEFT = 28;
|
|
private static final int RIGHT_TO_RIGHT = 29;
|
|
private static final int START_MARGIN = 30;
|
|
private static final int START_TO_END = 31;
|
|
private static final int START_TO_START = 32;
|
|
private static final int TOP_MARGIN = 33;
|
|
private static final int TOP_TO_BOTTOM = 34;
|
|
private static final int TOP_TO_TOP = 35;
|
|
public static final int UNSET = -1;
|
|
private static final int UNUSED = 76;
|
|
private static final int VERTICAL_BIAS = 36;
|
|
private static final int VERTICAL_STYLE = 40;
|
|
private static final int VERTICAL_WEIGHT = 38;
|
|
private static final int WIDTH_PERCENT = 69;
|
|
private static SparseIntArray mapToConstant;
|
|
public int baselineToBaseline = -1;
|
|
public int bottomMargin = -1;
|
|
public int bottomToBottom = -1;
|
|
public int bottomToTop = -1;
|
|
public float circleAngle = 0.0f;
|
|
public int circleConstraint = -1;
|
|
public int circleRadius = 0;
|
|
public boolean constrainedHeight = false;
|
|
public boolean constrainedWidth = false;
|
|
public String dimensionRatio = null;
|
|
public int editorAbsoluteX = -1;
|
|
public int editorAbsoluteY = -1;
|
|
public int endMargin = -1;
|
|
public int endToEnd = -1;
|
|
public int endToStart = -1;
|
|
public int goneBottomMargin = -1;
|
|
public int goneEndMargin = -1;
|
|
public int goneLeftMargin = -1;
|
|
public int goneRightMargin = -1;
|
|
public int goneStartMargin = -1;
|
|
public int goneTopMargin = -1;
|
|
public int guideBegin = -1;
|
|
public int guideEnd = -1;
|
|
public float guidePercent = -1.0f;
|
|
public int heightDefault = 0;
|
|
public int heightMax = -1;
|
|
public int heightMin = -1;
|
|
public float heightPercent = 1.0f;
|
|
public float horizontalBias = 0.5f;
|
|
public int horizontalChainStyle = 0;
|
|
public float horizontalWeight = -1.0f;
|
|
public int leftMargin = -1;
|
|
public int leftToLeft = -1;
|
|
public int leftToRight = -1;
|
|
public boolean mApply = false;
|
|
public boolean mBarrierAllowsGoneWidgets = true;
|
|
public int mBarrierDirection = -1;
|
|
public int mBarrierMargin = 0;
|
|
public String mConstraintTag;
|
|
public int mHeight;
|
|
public int mHelperType = -1;
|
|
public boolean mIsGuideline = false;
|
|
public String mReferenceIdString;
|
|
public int[] mReferenceIds;
|
|
public int mWidth;
|
|
public int orientation = -1;
|
|
public int rightMargin = -1;
|
|
public int rightToLeft = -1;
|
|
public int rightToRight = -1;
|
|
public int startMargin = -1;
|
|
public int startToEnd = -1;
|
|
public int startToStart = -1;
|
|
public int topMargin = -1;
|
|
public int topToBottom = -1;
|
|
public int topToTop = -1;
|
|
public float verticalBias = 0.5f;
|
|
public int verticalChainStyle = 0;
|
|
public float verticalWeight = -1.0f;
|
|
public int widthDefault = 0;
|
|
public int widthMax = -1;
|
|
public int widthMin = -1;
|
|
public float widthPercent = 1.0f;
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
mapToConstant = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.Layout_layout_constraintLeft_toLeftOf, 24);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintLeft_toRightOf, 25);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintRight_toLeftOf, 28);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintRight_toRightOf, 29);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintTop_toTopOf, 35);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintTop_toBottomOf, 34);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintBottom_toTopOf, 4);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintBottom_toBottomOf, 3);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintBaseline_toBaselineOf, 1);
|
|
mapToConstant.append(R.styleable.Layout_layout_editor_absoluteX, 6);
|
|
mapToConstant.append(R.styleable.Layout_layout_editor_absoluteY, 7);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintGuide_begin, 17);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintGuide_end, 18);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintGuide_percent, 19);
|
|
mapToConstant.append(R.styleable.Layout_android_orientation, 26);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintStart_toEndOf, 31);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintStart_toStartOf, 32);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintEnd_toStartOf, 10);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintEnd_toEndOf, 9);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginLeft, 13);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginTop, 16);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginRight, 14);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginBottom, 11);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginStart, 15);
|
|
mapToConstant.append(R.styleable.Layout_layout_goneMarginEnd, 12);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintVertical_weight, 38);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintHorizontal_weight, 37);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintHorizontal_chainStyle, 39);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintVertical_chainStyle, 40);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintHorizontal_bias, 20);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintVertical_bias, 36);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintDimensionRatio, 5);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintLeft_creator, 76);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintTop_creator, 76);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintRight_creator, 76);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintBottom_creator, 76);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintBaseline_creator, 76);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginLeft, 23);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginRight, 27);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginStart, 30);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginEnd, 8);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginTop, 33);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_marginBottom, 2);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_width, 22);
|
|
mapToConstant.append(R.styleable.Layout_android_layout_height, 21);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintCircle, 61);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintCircleRadius, 62);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintCircleAngle, 63);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintWidth_percent, 69);
|
|
mapToConstant.append(R.styleable.Layout_layout_constraintHeight_percent, 70);
|
|
mapToConstant.append(R.styleable.Layout_chainUseRtl, 71);
|
|
mapToConstant.append(R.styleable.Layout_barrierDirection, 72);
|
|
mapToConstant.append(R.styleable.Layout_barrierMargin, 73);
|
|
mapToConstant.append(R.styleable.Layout_constraint_referenced_ids, 74);
|
|
mapToConstant.append(R.styleable.Layout_barrierAllowsGoneWidgets, 75);
|
|
}
|
|
|
|
public void copyFrom(Layout layout) {
|
|
this.mIsGuideline = layout.mIsGuideline;
|
|
this.mWidth = layout.mWidth;
|
|
this.mApply = layout.mApply;
|
|
this.mHeight = layout.mHeight;
|
|
this.guideBegin = layout.guideBegin;
|
|
this.guideEnd = layout.guideEnd;
|
|
this.guidePercent = layout.guidePercent;
|
|
this.leftToLeft = layout.leftToLeft;
|
|
this.leftToRight = layout.leftToRight;
|
|
this.rightToLeft = layout.rightToLeft;
|
|
this.rightToRight = layout.rightToRight;
|
|
this.topToTop = layout.topToTop;
|
|
this.topToBottom = layout.topToBottom;
|
|
this.bottomToTop = layout.bottomToTop;
|
|
this.bottomToBottom = layout.bottomToBottom;
|
|
this.baselineToBaseline = layout.baselineToBaseline;
|
|
this.startToEnd = layout.startToEnd;
|
|
this.startToStart = layout.startToStart;
|
|
this.endToStart = layout.endToStart;
|
|
this.endToEnd = layout.endToEnd;
|
|
this.horizontalBias = layout.horizontalBias;
|
|
this.verticalBias = layout.verticalBias;
|
|
this.dimensionRatio = layout.dimensionRatio;
|
|
this.circleConstraint = layout.circleConstraint;
|
|
this.circleRadius = layout.circleRadius;
|
|
this.circleAngle = layout.circleAngle;
|
|
this.editorAbsoluteX = layout.editorAbsoluteX;
|
|
this.editorAbsoluteY = layout.editorAbsoluteY;
|
|
this.orientation = layout.orientation;
|
|
this.leftMargin = layout.leftMargin;
|
|
this.rightMargin = layout.rightMargin;
|
|
this.topMargin = layout.topMargin;
|
|
this.bottomMargin = layout.bottomMargin;
|
|
this.endMargin = layout.endMargin;
|
|
this.startMargin = layout.startMargin;
|
|
this.goneLeftMargin = layout.goneLeftMargin;
|
|
this.goneTopMargin = layout.goneTopMargin;
|
|
this.goneRightMargin = layout.goneRightMargin;
|
|
this.goneBottomMargin = layout.goneBottomMargin;
|
|
this.goneEndMargin = layout.goneEndMargin;
|
|
this.goneStartMargin = layout.goneStartMargin;
|
|
this.verticalWeight = layout.verticalWeight;
|
|
this.horizontalWeight = layout.horizontalWeight;
|
|
this.horizontalChainStyle = layout.horizontalChainStyle;
|
|
this.verticalChainStyle = layout.verticalChainStyle;
|
|
this.widthDefault = layout.widthDefault;
|
|
this.heightDefault = layout.heightDefault;
|
|
this.widthMax = layout.widthMax;
|
|
this.heightMax = layout.heightMax;
|
|
this.widthMin = layout.widthMin;
|
|
this.heightMin = layout.heightMin;
|
|
this.widthPercent = layout.widthPercent;
|
|
this.heightPercent = layout.heightPercent;
|
|
this.mBarrierDirection = layout.mBarrierDirection;
|
|
this.mBarrierMargin = layout.mBarrierMargin;
|
|
this.mHelperType = layout.mHelperType;
|
|
this.mConstraintTag = layout.mConstraintTag;
|
|
int[] iArr = layout.mReferenceIds;
|
|
if (iArr != null) {
|
|
this.mReferenceIds = Arrays.copyOf(iArr, iArr.length);
|
|
} else {
|
|
this.mReferenceIds = null;
|
|
}
|
|
this.mReferenceIdString = layout.mReferenceIdString;
|
|
this.constrainedWidth = layout.constrainedWidth;
|
|
this.constrainedHeight = layout.constrainedHeight;
|
|
this.mBarrierAllowsGoneWidgets = layout.mBarrierAllowsGoneWidgets;
|
|
}
|
|
|
|
public void dump(MotionScene motionScene, StringBuilder sb) {
|
|
Field[] declaredFields = getClass().getDeclaredFields();
|
|
sb.append("\n");
|
|
for (Field field : declaredFields) {
|
|
String name = field.getName();
|
|
if (!Modifier.isStatic(field.getModifiers())) {
|
|
try {
|
|
Object obj = field.get(this);
|
|
Class<?> type = field.getType();
|
|
if (type == Integer.TYPE) {
|
|
Integer num = (Integer) obj;
|
|
if (num.intValue() != -1) {
|
|
Object lookUpConstraintName = motionScene.lookUpConstraintName(num.intValue());
|
|
sb.append(" ");
|
|
sb.append(name);
|
|
sb.append(" = \"");
|
|
Integer num2 = num;
|
|
if (lookUpConstraintName != null) {
|
|
num2 = lookUpConstraintName;
|
|
}
|
|
sb.append(num2);
|
|
sb.append("\"\n");
|
|
}
|
|
} else if (type == Float.TYPE) {
|
|
Float f = (Float) obj;
|
|
if (f.floatValue() != -1.0f) {
|
|
sb.append(" ");
|
|
sb.append(name);
|
|
sb.append(" = \"");
|
|
sb.append(f);
|
|
sb.append("\"\n");
|
|
}
|
|
}
|
|
} catch (IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void fillFromAttributeList(Context context, AttributeSet attributeSet) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Layout);
|
|
this.mApply = true;
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
int i2 = mapToConstant.get(index);
|
|
if (i2 == 80) {
|
|
this.constrainedWidth = obtainStyledAttributes.getBoolean(index, this.constrainedWidth);
|
|
} else if (i2 != 81) {
|
|
switch (i2) {
|
|
case 1:
|
|
this.baselineToBaseline = ConstraintSet.access$100(obtainStyledAttributes, index, this.baselineToBaseline);
|
|
continue;
|
|
case 2:
|
|
this.bottomMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.bottomMargin);
|
|
continue;
|
|
case 3:
|
|
this.bottomToBottom = ConstraintSet.access$100(obtainStyledAttributes, index, this.bottomToBottom);
|
|
continue;
|
|
case 4:
|
|
this.bottomToTop = ConstraintSet.access$100(obtainStyledAttributes, index, this.bottomToTop);
|
|
continue;
|
|
case 5:
|
|
this.dimensionRatio = obtainStyledAttributes.getString(index);
|
|
continue;
|
|
case 6:
|
|
this.editorAbsoluteX = obtainStyledAttributes.getDimensionPixelOffset(index, this.editorAbsoluteX);
|
|
continue;
|
|
case 7:
|
|
this.editorAbsoluteY = obtainStyledAttributes.getDimensionPixelOffset(index, this.editorAbsoluteY);
|
|
continue;
|
|
case 8:
|
|
this.endMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.endMargin);
|
|
continue;
|
|
case 9:
|
|
this.endToEnd = ConstraintSet.access$100(obtainStyledAttributes, index, this.endToEnd);
|
|
continue;
|
|
case 10:
|
|
this.endToStart = ConstraintSet.access$100(obtainStyledAttributes, index, this.endToStart);
|
|
continue;
|
|
case 11:
|
|
this.goneBottomMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneBottomMargin);
|
|
continue;
|
|
case 12:
|
|
this.goneEndMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneEndMargin);
|
|
continue;
|
|
case 13:
|
|
this.goneLeftMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneLeftMargin);
|
|
continue;
|
|
case 14:
|
|
this.goneRightMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneRightMargin);
|
|
continue;
|
|
case 15:
|
|
this.goneStartMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneStartMargin);
|
|
continue;
|
|
case 16:
|
|
this.goneTopMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.goneTopMargin);
|
|
continue;
|
|
case 17:
|
|
this.guideBegin = obtainStyledAttributes.getDimensionPixelOffset(index, this.guideBegin);
|
|
continue;
|
|
case 18:
|
|
this.guideEnd = obtainStyledAttributes.getDimensionPixelOffset(index, this.guideEnd);
|
|
continue;
|
|
case 19:
|
|
this.guidePercent = obtainStyledAttributes.getFloat(index, this.guidePercent);
|
|
continue;
|
|
case 20:
|
|
this.horizontalBias = obtainStyledAttributes.getFloat(index, this.horizontalBias);
|
|
continue;
|
|
case 21:
|
|
this.mHeight = obtainStyledAttributes.getLayoutDimension(index, this.mHeight);
|
|
continue;
|
|
case 22:
|
|
this.mWidth = obtainStyledAttributes.getLayoutDimension(index, this.mWidth);
|
|
continue;
|
|
case 23:
|
|
this.leftMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.leftMargin);
|
|
continue;
|
|
case 24:
|
|
this.leftToLeft = ConstraintSet.access$100(obtainStyledAttributes, index, this.leftToLeft);
|
|
continue;
|
|
case 25:
|
|
this.leftToRight = ConstraintSet.access$100(obtainStyledAttributes, index, this.leftToRight);
|
|
continue;
|
|
case 26:
|
|
this.orientation = obtainStyledAttributes.getInt(index, this.orientation);
|
|
continue;
|
|
case 27:
|
|
this.rightMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.rightMargin);
|
|
continue;
|
|
case 28:
|
|
this.rightToLeft = ConstraintSet.access$100(obtainStyledAttributes, index, this.rightToLeft);
|
|
continue;
|
|
case 29:
|
|
this.rightToRight = ConstraintSet.access$100(obtainStyledAttributes, index, this.rightToRight);
|
|
continue;
|
|
case 30:
|
|
this.startMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.startMargin);
|
|
continue;
|
|
case 31:
|
|
this.startToEnd = ConstraintSet.access$100(obtainStyledAttributes, index, this.startToEnd);
|
|
continue;
|
|
case 32:
|
|
this.startToStart = ConstraintSet.access$100(obtainStyledAttributes, index, this.startToStart);
|
|
continue;
|
|
case 33:
|
|
this.topMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.topMargin);
|
|
continue;
|
|
case 34:
|
|
this.topToBottom = ConstraintSet.access$100(obtainStyledAttributes, index, this.topToBottom);
|
|
continue;
|
|
case 35:
|
|
this.topToTop = ConstraintSet.access$100(obtainStyledAttributes, index, this.topToTop);
|
|
continue;
|
|
case 36:
|
|
this.verticalBias = obtainStyledAttributes.getFloat(index, this.verticalBias);
|
|
continue;
|
|
case 37:
|
|
this.horizontalWeight = obtainStyledAttributes.getFloat(index, this.horizontalWeight);
|
|
continue;
|
|
case 38:
|
|
this.verticalWeight = obtainStyledAttributes.getFloat(index, this.verticalWeight);
|
|
continue;
|
|
case 39:
|
|
this.horizontalChainStyle = obtainStyledAttributes.getInt(index, this.horizontalChainStyle);
|
|
continue;
|
|
case 40:
|
|
this.verticalChainStyle = obtainStyledAttributes.getInt(index, this.verticalChainStyle);
|
|
continue;
|
|
default:
|
|
switch (i2) {
|
|
case 54:
|
|
this.widthDefault = obtainStyledAttributes.getInt(index, this.widthDefault);
|
|
continue;
|
|
case 55:
|
|
this.heightDefault = obtainStyledAttributes.getInt(index, this.heightDefault);
|
|
continue;
|
|
case 56:
|
|
this.widthMax = obtainStyledAttributes.getDimensionPixelSize(index, this.widthMax);
|
|
continue;
|
|
case 57:
|
|
this.heightMax = obtainStyledAttributes.getDimensionPixelSize(index, this.heightMax);
|
|
continue;
|
|
case 58:
|
|
this.widthMin = obtainStyledAttributes.getDimensionPixelSize(index, this.widthMin);
|
|
continue;
|
|
case 59:
|
|
this.heightMin = obtainStyledAttributes.getDimensionPixelSize(index, this.heightMin);
|
|
continue;
|
|
default:
|
|
switch (i2) {
|
|
case 61:
|
|
this.circleConstraint = ConstraintSet.access$100(obtainStyledAttributes, index, this.circleConstraint);
|
|
continue;
|
|
case 62:
|
|
this.circleRadius = obtainStyledAttributes.getDimensionPixelSize(index, this.circleRadius);
|
|
continue;
|
|
case 63:
|
|
this.circleAngle = obtainStyledAttributes.getFloat(index, this.circleAngle);
|
|
continue;
|
|
default:
|
|
switch (i2) {
|
|
case 69:
|
|
this.widthPercent = obtainStyledAttributes.getFloat(index, 1.0f);
|
|
continue;
|
|
case 70:
|
|
this.heightPercent = obtainStyledAttributes.getFloat(index, 1.0f);
|
|
continue;
|
|
case 71:
|
|
Log.e(ConstraintSet.TAG, "CURRENTLY UNSUPPORTED");
|
|
continue;
|
|
case 72:
|
|
this.mBarrierDirection = obtainStyledAttributes.getInt(index, this.mBarrierDirection);
|
|
continue;
|
|
case 73:
|
|
this.mBarrierMargin = obtainStyledAttributes.getDimensionPixelSize(index, this.mBarrierMargin);
|
|
continue;
|
|
case 74:
|
|
this.mReferenceIdString = obtainStyledAttributes.getString(index);
|
|
continue;
|
|
case 75:
|
|
this.mBarrierAllowsGoneWidgets = obtainStyledAttributes.getBoolean(index, this.mBarrierAllowsGoneWidgets);
|
|
continue;
|
|
case 76:
|
|
StringBuilder L = a.L("unused attribute 0x");
|
|
L.append(Integer.toHexString(index));
|
|
L.append(" ");
|
|
L.append(mapToConstant.get(index));
|
|
Log.w(ConstraintSet.TAG, L.toString());
|
|
continue;
|
|
case 77:
|
|
this.mConstraintTag = obtainStyledAttributes.getString(index);
|
|
continue;
|
|
default:
|
|
StringBuilder L2 = a.L("Unknown attribute 0x");
|
|
L2.append(Integer.toHexString(index));
|
|
L2.append(" ");
|
|
L2.append(mapToConstant.get(index));
|
|
Log.w(ConstraintSet.TAG, L2.toString());
|
|
continue;
|
|
continue;
|
|
continue;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
this.constrainedHeight = obtainStyledAttributes.getBoolean(index, this.constrainedHeight);
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
public static class Motion {
|
|
private static final int ANIMATE_RELATIVE_TO = 5;
|
|
private static final int MOTION_DRAW_PATH = 4;
|
|
private static final int MOTION_STAGGER = 6;
|
|
private static final int PATH_MOTION_ARC = 2;
|
|
private static final int TRANSITION_EASING = 3;
|
|
private static final int TRANSITION_PATH_ROTATE = 1;
|
|
private static SparseIntArray mapToConstant;
|
|
public int mAnimateRelativeTo = -1;
|
|
public boolean mApply = false;
|
|
public int mDrawPath = 0;
|
|
public float mMotionStagger = Float.NaN;
|
|
public int mPathMotionArc = -1;
|
|
public float mPathRotate = Float.NaN;
|
|
public String mTransitionEasing = null;
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
mapToConstant = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.Motion_motionPathRotate, 1);
|
|
mapToConstant.append(R.styleable.Motion_pathMotionArc, 2);
|
|
mapToConstant.append(R.styleable.Motion_transitionEasing, 3);
|
|
mapToConstant.append(R.styleable.Motion_drawPath, 4);
|
|
mapToConstant.append(R.styleable.Motion_animate_relativeTo, 5);
|
|
mapToConstant.append(R.styleable.Motion_motionStagger, 6);
|
|
}
|
|
|
|
public void copyFrom(Motion motion) {
|
|
this.mApply = motion.mApply;
|
|
this.mAnimateRelativeTo = motion.mAnimateRelativeTo;
|
|
this.mTransitionEasing = motion.mTransitionEasing;
|
|
this.mPathMotionArc = motion.mPathMotionArc;
|
|
this.mDrawPath = motion.mDrawPath;
|
|
this.mPathRotate = motion.mPathRotate;
|
|
this.mMotionStagger = motion.mMotionStagger;
|
|
}
|
|
|
|
public void fillFromAttributeList(Context context, AttributeSet attributeSet) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Motion);
|
|
this.mApply = true;
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
switch (mapToConstant.get(index)) {
|
|
case 1:
|
|
this.mPathRotate = obtainStyledAttributes.getFloat(index, this.mPathRotate);
|
|
break;
|
|
case 2:
|
|
this.mPathMotionArc = obtainStyledAttributes.getInt(index, this.mPathMotionArc);
|
|
break;
|
|
case 3:
|
|
if (obtainStyledAttributes.peekValue(index).type == 3) {
|
|
this.mTransitionEasing = obtainStyledAttributes.getString(index);
|
|
break;
|
|
} else {
|
|
this.mTransitionEasing = Easing.NAMED_EASING[obtainStyledAttributes.getInteger(index, 0)];
|
|
break;
|
|
}
|
|
case 4:
|
|
this.mDrawPath = obtainStyledAttributes.getInt(index, 0);
|
|
break;
|
|
case 5:
|
|
this.mAnimateRelativeTo = ConstraintSet.access$100(obtainStyledAttributes, index, this.mAnimateRelativeTo);
|
|
break;
|
|
case 6:
|
|
this.mMotionStagger = obtainStyledAttributes.getFloat(index, this.mMotionStagger);
|
|
break;
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
public static class PropertySet {
|
|
public float alpha = 1.0f;
|
|
public boolean mApply = false;
|
|
public float mProgress = Float.NaN;
|
|
public int mVisibilityMode = 0;
|
|
public int visibility = 0;
|
|
|
|
public void copyFrom(PropertySet propertySet) {
|
|
this.mApply = propertySet.mApply;
|
|
this.visibility = propertySet.visibility;
|
|
this.alpha = propertySet.alpha;
|
|
this.mProgress = propertySet.mProgress;
|
|
this.mVisibilityMode = propertySet.mVisibilityMode;
|
|
}
|
|
|
|
public void fillFromAttributeList(Context context, AttributeSet attributeSet) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.PropertySet);
|
|
this.mApply = true;
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
if (index == R.styleable.PropertySet_android_alpha) {
|
|
this.alpha = obtainStyledAttributes.getFloat(index, this.alpha);
|
|
} else if (index == R.styleable.PropertySet_android_visibility) {
|
|
this.visibility = obtainStyledAttributes.getInt(index, this.visibility);
|
|
this.visibility = ConstraintSet.access$200()[this.visibility];
|
|
} else if (index == R.styleable.PropertySet_visibilityMode) {
|
|
this.mVisibilityMode = obtainStyledAttributes.getInt(index, this.mVisibilityMode);
|
|
} else if (index == R.styleable.PropertySet_motionProgress) {
|
|
this.mProgress = obtainStyledAttributes.getFloat(index, this.mProgress);
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
public static class Transform {
|
|
private static final int ELEVATION = 11;
|
|
private static final int ROTATION = 1;
|
|
private static final int ROTATION_X = 2;
|
|
private static final int ROTATION_Y = 3;
|
|
private static final int SCALE_X = 4;
|
|
private static final int SCALE_Y = 5;
|
|
private static final int TRANSFORM_PIVOT_X = 6;
|
|
private static final int TRANSFORM_PIVOT_Y = 7;
|
|
private static final int TRANSLATION_X = 8;
|
|
private static final int TRANSLATION_Y = 9;
|
|
private static final int TRANSLATION_Z = 10;
|
|
private static SparseIntArray mapToConstant;
|
|
public boolean applyElevation = false;
|
|
public float elevation = 0.0f;
|
|
public boolean mApply = false;
|
|
public float rotation = 0.0f;
|
|
public float rotationX = 0.0f;
|
|
public float rotationY = 0.0f;
|
|
public float scaleX = 1.0f;
|
|
public float scaleY = 1.0f;
|
|
public float transformPivotX = Float.NaN;
|
|
public float transformPivotY = Float.NaN;
|
|
public float translationX = 0.0f;
|
|
public float translationY = 0.0f;
|
|
public float translationZ = 0.0f;
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
mapToConstant = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.Transform_android_rotation, 1);
|
|
mapToConstant.append(R.styleable.Transform_android_rotationX, 2);
|
|
mapToConstant.append(R.styleable.Transform_android_rotationY, 3);
|
|
mapToConstant.append(R.styleable.Transform_android_scaleX, 4);
|
|
mapToConstant.append(R.styleable.Transform_android_scaleY, 5);
|
|
mapToConstant.append(R.styleable.Transform_android_transformPivotX, 6);
|
|
mapToConstant.append(R.styleable.Transform_android_transformPivotY, 7);
|
|
mapToConstant.append(R.styleable.Transform_android_translationX, 8);
|
|
mapToConstant.append(R.styleable.Transform_android_translationY, 9);
|
|
mapToConstant.append(R.styleable.Transform_android_translationZ, 10);
|
|
mapToConstant.append(R.styleable.Transform_android_elevation, 11);
|
|
}
|
|
|
|
public void copyFrom(Transform transform) {
|
|
this.mApply = transform.mApply;
|
|
this.rotation = transform.rotation;
|
|
this.rotationX = transform.rotationX;
|
|
this.rotationY = transform.rotationY;
|
|
this.scaleX = transform.scaleX;
|
|
this.scaleY = transform.scaleY;
|
|
this.transformPivotX = transform.transformPivotX;
|
|
this.transformPivotY = transform.transformPivotY;
|
|
this.translationX = transform.translationX;
|
|
this.translationY = transform.translationY;
|
|
this.translationZ = transform.translationZ;
|
|
this.applyElevation = transform.applyElevation;
|
|
this.elevation = transform.elevation;
|
|
}
|
|
|
|
public void fillFromAttributeList(Context context, AttributeSet attributeSet) {
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Transform);
|
|
this.mApply = true;
|
|
int indexCount = obtainStyledAttributes.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = obtainStyledAttributes.getIndex(i);
|
|
switch (mapToConstant.get(index)) {
|
|
case 1:
|
|
this.rotation = obtainStyledAttributes.getFloat(index, this.rotation);
|
|
break;
|
|
case 2:
|
|
this.rotationX = obtainStyledAttributes.getFloat(index, this.rotationX);
|
|
break;
|
|
case 3:
|
|
this.rotationY = obtainStyledAttributes.getFloat(index, this.rotationY);
|
|
break;
|
|
case 4:
|
|
this.scaleX = obtainStyledAttributes.getFloat(index, this.scaleX);
|
|
break;
|
|
case 5:
|
|
this.scaleY = obtainStyledAttributes.getFloat(index, this.scaleY);
|
|
break;
|
|
case 6:
|
|
this.transformPivotX = obtainStyledAttributes.getDimension(index, this.transformPivotX);
|
|
break;
|
|
case 7:
|
|
this.transformPivotY = obtainStyledAttributes.getDimension(index, this.transformPivotY);
|
|
break;
|
|
case 8:
|
|
this.translationX = obtainStyledAttributes.getDimension(index, this.translationX);
|
|
break;
|
|
case 9:
|
|
this.translationY = obtainStyledAttributes.getDimension(index, this.translationY);
|
|
break;
|
|
case 10:
|
|
this.translationZ = obtainStyledAttributes.getDimension(index, this.translationZ);
|
|
break;
|
|
case 11:
|
|
this.applyElevation = true;
|
|
this.elevation = obtainStyledAttributes.getDimension(index, this.elevation);
|
|
break;
|
|
}
|
|
}
|
|
obtainStyledAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
static {
|
|
SparseIntArray sparseIntArray = new SparseIntArray();
|
|
mapToConstant = sparseIntArray;
|
|
sparseIntArray.append(R.styleable.Constraint_layout_constraintLeft_toLeftOf, 25);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintLeft_toRightOf, 26);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintRight_toLeftOf, 29);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintRight_toRightOf, 30);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintTop_toTopOf, 36);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintTop_toBottomOf, 35);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintBottom_toTopOf, 4);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintBottom_toBottomOf, 3);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintBaseline_toBaselineOf, 1);
|
|
mapToConstant.append(R.styleable.Constraint_layout_editor_absoluteX, 6);
|
|
mapToConstant.append(R.styleable.Constraint_layout_editor_absoluteY, 7);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintGuide_begin, 17);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintGuide_end, 18);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintGuide_percent, 19);
|
|
mapToConstant.append(R.styleable.Constraint_android_orientation, 27);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintStart_toEndOf, 32);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintStart_toStartOf, 33);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintEnd_toStartOf, 10);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintEnd_toEndOf, 9);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginLeft, 13);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginTop, 16);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginRight, 14);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginBottom, 11);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginStart, 15);
|
|
mapToConstant.append(R.styleable.Constraint_layout_goneMarginEnd, 12);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintVertical_weight, 40);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHorizontal_weight, 39);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHorizontal_chainStyle, 41);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintVertical_chainStyle, 42);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHorizontal_bias, 20);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintVertical_bias, 37);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintDimensionRatio, 5);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintLeft_creator, 82);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintTop_creator, 82);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintRight_creator, 82);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintBottom_creator, 82);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintBaseline_creator, 82);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginLeft, 24);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginRight, 28);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginStart, 31);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginEnd, 8);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginTop, 34);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_marginBottom, 2);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_width, 23);
|
|
mapToConstant.append(R.styleable.Constraint_android_layout_height, 21);
|
|
mapToConstant.append(R.styleable.Constraint_android_visibility, 22);
|
|
mapToConstant.append(R.styleable.Constraint_android_alpha, 43);
|
|
mapToConstant.append(R.styleable.Constraint_android_elevation, 44);
|
|
mapToConstant.append(R.styleable.Constraint_android_rotationX, 45);
|
|
mapToConstant.append(R.styleable.Constraint_android_rotationY, 46);
|
|
mapToConstant.append(R.styleable.Constraint_android_rotation, 60);
|
|
mapToConstant.append(R.styleable.Constraint_android_scaleX, 47);
|
|
mapToConstant.append(R.styleable.Constraint_android_scaleY, 48);
|
|
mapToConstant.append(R.styleable.Constraint_android_transformPivotX, 49);
|
|
mapToConstant.append(R.styleable.Constraint_android_transformPivotY, 50);
|
|
mapToConstant.append(R.styleable.Constraint_android_translationX, 51);
|
|
mapToConstant.append(R.styleable.Constraint_android_translationY, 52);
|
|
mapToConstant.append(R.styleable.Constraint_android_translationZ, 53);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintWidth_default, 54);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHeight_default, 55);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintWidth_max, 56);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHeight_max, 57);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintWidth_min, 58);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHeight_min, 59);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintCircle, 61);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintCircleRadius, 62);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintCircleAngle, 63);
|
|
mapToConstant.append(R.styleable.Constraint_animate_relativeTo, 64);
|
|
mapToConstant.append(R.styleable.Constraint_transitionEasing, 65);
|
|
mapToConstant.append(R.styleable.Constraint_drawPath, 66);
|
|
mapToConstant.append(R.styleable.Constraint_transitionPathRotate, 67);
|
|
mapToConstant.append(R.styleable.Constraint_motionStagger, 79);
|
|
mapToConstant.append(R.styleable.Constraint_android_id, 38);
|
|
mapToConstant.append(R.styleable.Constraint_motionProgress, 68);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintWidth_percent, 69);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintHeight_percent, 70);
|
|
mapToConstant.append(R.styleable.Constraint_chainUseRtl, 71);
|
|
mapToConstant.append(R.styleable.Constraint_barrierDirection, 72);
|
|
mapToConstant.append(R.styleable.Constraint_barrierMargin, 73);
|
|
mapToConstant.append(R.styleable.Constraint_constraint_referenced_ids, 74);
|
|
mapToConstant.append(R.styleable.Constraint_barrierAllowsGoneWidgets, 75);
|
|
mapToConstant.append(R.styleable.Constraint_pathMotionArc, 76);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constraintTag, 77);
|
|
mapToConstant.append(R.styleable.Constraint_visibilityMode, 78);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constrainedWidth, 80);
|
|
mapToConstant.append(R.styleable.Constraint_layout_constrainedHeight, 81);
|
|
}
|
|
|
|
public static /* synthetic */ int access$100(TypedArray typedArray, int i, int i2) {
|
|
return lookupID(typedArray, i, i2);
|
|
}
|
|
|
|
public static /* synthetic */ int[] access$200() {
|
|
return VISIBILITY_FLAGS;
|
|
}
|
|
|
|
private void addAttributes(ConstraintAttribute.AttributeType attributeType, String... strArr) {
|
|
for (int i = 0; i < strArr.length; i++) {
|
|
if (this.mSavedAttributes.containsKey(strArr[i])) {
|
|
ConstraintAttribute constraintAttribute = this.mSavedAttributes.get(strArr[i]);
|
|
if (constraintAttribute.getType() != attributeType) {
|
|
StringBuilder L = a.L("ConstraintAttribute is already a ");
|
|
L.append(constraintAttribute.getType().name());
|
|
throw new IllegalArgumentException(L.toString());
|
|
}
|
|
} else {
|
|
this.mSavedAttributes.put(strArr[i], new ConstraintAttribute(strArr[i], attributeType));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int[] convertReferenceString(View view, String str) {
|
|
int i;
|
|
Object designInformation;
|
|
String[] split = str.split(",");
|
|
Context context = view.getContext();
|
|
int[] iArr = new int[split.length];
|
|
int i2 = 0;
|
|
int i3 = 0;
|
|
while (i2 < split.length) {
|
|
String trim = split[i2].trim();
|
|
try {
|
|
i = R.id.class.getField(trim).getInt(null);
|
|
} catch (Exception unused) {
|
|
i = 0;
|
|
}
|
|
if (i == 0) {
|
|
i = context.getResources().getIdentifier(trim, ModelAuditLogEntry.CHANGE_KEY_ID, context.getPackageName());
|
|
}
|
|
if (i == 0 && view.isInEditMode() && (view.getParent() instanceof ConstraintLayout) && (designInformation = ((ConstraintLayout) view.getParent()).getDesignInformation(0, trim)) != null && (designInformation instanceof Integer)) {
|
|
i = ((Integer) designInformation).intValue();
|
|
}
|
|
iArr[i3] = i;
|
|
i2++;
|
|
i3++;
|
|
}
|
|
return i3 != split.length ? Arrays.copyOf(iArr, i3) : iArr;
|
|
}
|
|
|
|
private void createHorizontalChain(int i, int i2, int i3, int i4, int[] iArr, float[] fArr, int i5, int i6, int i7) {
|
|
if (iArr.length < 2) {
|
|
throw new IllegalArgumentException("must have 2 or more widgets in a chain");
|
|
} else if (fArr == null || fArr.length == iArr.length) {
|
|
if (fArr != null) {
|
|
get(iArr[0]).layout.horizontalWeight = fArr[0];
|
|
}
|
|
get(iArr[0]).layout.horizontalChainStyle = i5;
|
|
connect(iArr[0], i6, i, i2, -1);
|
|
for (int i8 = 1; i8 < iArr.length; i8++) {
|
|
int i9 = iArr[i8];
|
|
int i10 = i8 - 1;
|
|
connect(iArr[i8], i6, iArr[i10], i7, -1);
|
|
connect(iArr[i10], i7, iArr[i8], i6, -1);
|
|
if (fArr != null) {
|
|
get(iArr[i8]).layout.horizontalWeight = fArr[i8];
|
|
}
|
|
}
|
|
connect(iArr[iArr.length - 1], i7, i3, i4, -1);
|
|
} else {
|
|
throw new IllegalArgumentException("must have 2 or more widgets in a chain");
|
|
}
|
|
}
|
|
|
|
private Constraint fillFromAttributeList(Context context, AttributeSet attributeSet) {
|
|
Constraint constraint = new Constraint();
|
|
TypedArray obtainStyledAttributes = context.obtainStyledAttributes(attributeSet, R.styleable.Constraint);
|
|
populateConstraint(context, constraint, obtainStyledAttributes);
|
|
obtainStyledAttributes.recycle();
|
|
return constraint;
|
|
}
|
|
|
|
private Constraint get(int i) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
this.mConstraints.put(Integer.valueOf(i), new Constraint());
|
|
}
|
|
return this.mConstraints.get(Integer.valueOf(i));
|
|
}
|
|
|
|
private static int lookupID(TypedArray typedArray, int i, int i2) {
|
|
int resourceId = typedArray.getResourceId(i, i2);
|
|
return resourceId == -1 ? typedArray.getInt(i, -1) : resourceId;
|
|
}
|
|
|
|
private void populateConstraint(Context context, Constraint constraint, TypedArray typedArray) {
|
|
int indexCount = typedArray.getIndexCount();
|
|
for (int i = 0; i < indexCount; i++) {
|
|
int index = typedArray.getIndex(i);
|
|
if (!(index == R.styleable.Constraint_android_id || R.styleable.Constraint_android_layout_marginStart == index || R.styleable.Constraint_android_layout_marginEnd == index)) {
|
|
constraint.motion.mApply = true;
|
|
constraint.layout.mApply = true;
|
|
constraint.propertySet.mApply = true;
|
|
constraint.transform.mApply = true;
|
|
}
|
|
switch (mapToConstant.get(index)) {
|
|
case 1:
|
|
Layout layout = constraint.layout;
|
|
layout.baselineToBaseline = lookupID(typedArray, index, layout.baselineToBaseline);
|
|
break;
|
|
case 2:
|
|
Layout layout2 = constraint.layout;
|
|
layout2.bottomMargin = typedArray.getDimensionPixelSize(index, layout2.bottomMargin);
|
|
break;
|
|
case 3:
|
|
Layout layout3 = constraint.layout;
|
|
layout3.bottomToBottom = lookupID(typedArray, index, layout3.bottomToBottom);
|
|
break;
|
|
case 4:
|
|
Layout layout4 = constraint.layout;
|
|
layout4.bottomToTop = lookupID(typedArray, index, layout4.bottomToTop);
|
|
break;
|
|
case 5:
|
|
constraint.layout.dimensionRatio = typedArray.getString(index);
|
|
break;
|
|
case 6:
|
|
Layout layout5 = constraint.layout;
|
|
layout5.editorAbsoluteX = typedArray.getDimensionPixelOffset(index, layout5.editorAbsoluteX);
|
|
break;
|
|
case 7:
|
|
Layout layout6 = constraint.layout;
|
|
layout6.editorAbsoluteY = typedArray.getDimensionPixelOffset(index, layout6.editorAbsoluteY);
|
|
break;
|
|
case 8:
|
|
Layout layout7 = constraint.layout;
|
|
layout7.endMargin = typedArray.getDimensionPixelSize(index, layout7.endMargin);
|
|
break;
|
|
case 9:
|
|
Layout layout8 = constraint.layout;
|
|
layout8.endToEnd = lookupID(typedArray, index, layout8.endToEnd);
|
|
break;
|
|
case 10:
|
|
Layout layout9 = constraint.layout;
|
|
layout9.endToStart = lookupID(typedArray, index, layout9.endToStart);
|
|
break;
|
|
case 11:
|
|
Layout layout10 = constraint.layout;
|
|
layout10.goneBottomMargin = typedArray.getDimensionPixelSize(index, layout10.goneBottomMargin);
|
|
break;
|
|
case 12:
|
|
Layout layout11 = constraint.layout;
|
|
layout11.goneEndMargin = typedArray.getDimensionPixelSize(index, layout11.goneEndMargin);
|
|
break;
|
|
case 13:
|
|
Layout layout12 = constraint.layout;
|
|
layout12.goneLeftMargin = typedArray.getDimensionPixelSize(index, layout12.goneLeftMargin);
|
|
break;
|
|
case 14:
|
|
Layout layout13 = constraint.layout;
|
|
layout13.goneRightMargin = typedArray.getDimensionPixelSize(index, layout13.goneRightMargin);
|
|
break;
|
|
case 15:
|
|
Layout layout14 = constraint.layout;
|
|
layout14.goneStartMargin = typedArray.getDimensionPixelSize(index, layout14.goneStartMargin);
|
|
break;
|
|
case 16:
|
|
Layout layout15 = constraint.layout;
|
|
layout15.goneTopMargin = typedArray.getDimensionPixelSize(index, layout15.goneTopMargin);
|
|
break;
|
|
case 17:
|
|
Layout layout16 = constraint.layout;
|
|
layout16.guideBegin = typedArray.getDimensionPixelOffset(index, layout16.guideBegin);
|
|
break;
|
|
case 18:
|
|
Layout layout17 = constraint.layout;
|
|
layout17.guideEnd = typedArray.getDimensionPixelOffset(index, layout17.guideEnd);
|
|
break;
|
|
case 19:
|
|
Layout layout18 = constraint.layout;
|
|
layout18.guidePercent = typedArray.getFloat(index, layout18.guidePercent);
|
|
break;
|
|
case 20:
|
|
Layout layout19 = constraint.layout;
|
|
layout19.horizontalBias = typedArray.getFloat(index, layout19.horizontalBias);
|
|
break;
|
|
case 21:
|
|
Layout layout20 = constraint.layout;
|
|
layout20.mHeight = typedArray.getLayoutDimension(index, layout20.mHeight);
|
|
break;
|
|
case 22:
|
|
PropertySet propertySet = constraint.propertySet;
|
|
propertySet.visibility = typedArray.getInt(index, propertySet.visibility);
|
|
PropertySet propertySet2 = constraint.propertySet;
|
|
propertySet2.visibility = VISIBILITY_FLAGS[propertySet2.visibility];
|
|
break;
|
|
case 23:
|
|
Layout layout21 = constraint.layout;
|
|
layout21.mWidth = typedArray.getLayoutDimension(index, layout21.mWidth);
|
|
break;
|
|
case 24:
|
|
Layout layout22 = constraint.layout;
|
|
layout22.leftMargin = typedArray.getDimensionPixelSize(index, layout22.leftMargin);
|
|
break;
|
|
case 25:
|
|
Layout layout23 = constraint.layout;
|
|
layout23.leftToLeft = lookupID(typedArray, index, layout23.leftToLeft);
|
|
break;
|
|
case 26:
|
|
Layout layout24 = constraint.layout;
|
|
layout24.leftToRight = lookupID(typedArray, index, layout24.leftToRight);
|
|
break;
|
|
case 27:
|
|
Layout layout25 = constraint.layout;
|
|
layout25.orientation = typedArray.getInt(index, layout25.orientation);
|
|
break;
|
|
case 28:
|
|
Layout layout26 = constraint.layout;
|
|
layout26.rightMargin = typedArray.getDimensionPixelSize(index, layout26.rightMargin);
|
|
break;
|
|
case 29:
|
|
Layout layout27 = constraint.layout;
|
|
layout27.rightToLeft = lookupID(typedArray, index, layout27.rightToLeft);
|
|
break;
|
|
case 30:
|
|
Layout layout28 = constraint.layout;
|
|
layout28.rightToRight = lookupID(typedArray, index, layout28.rightToRight);
|
|
break;
|
|
case 31:
|
|
Layout layout29 = constraint.layout;
|
|
layout29.startMargin = typedArray.getDimensionPixelSize(index, layout29.startMargin);
|
|
break;
|
|
case 32:
|
|
Layout layout30 = constraint.layout;
|
|
layout30.startToEnd = lookupID(typedArray, index, layout30.startToEnd);
|
|
break;
|
|
case 33:
|
|
Layout layout31 = constraint.layout;
|
|
layout31.startToStart = lookupID(typedArray, index, layout31.startToStart);
|
|
break;
|
|
case 34:
|
|
Layout layout32 = constraint.layout;
|
|
layout32.topMargin = typedArray.getDimensionPixelSize(index, layout32.topMargin);
|
|
break;
|
|
case 35:
|
|
Layout layout33 = constraint.layout;
|
|
layout33.topToBottom = lookupID(typedArray, index, layout33.topToBottom);
|
|
break;
|
|
case 36:
|
|
Layout layout34 = constraint.layout;
|
|
layout34.topToTop = lookupID(typedArray, index, layout34.topToTop);
|
|
break;
|
|
case 37:
|
|
Layout layout35 = constraint.layout;
|
|
layout35.verticalBias = typedArray.getFloat(index, layout35.verticalBias);
|
|
break;
|
|
case 38:
|
|
constraint.mViewId = typedArray.getResourceId(index, constraint.mViewId);
|
|
break;
|
|
case 39:
|
|
Layout layout36 = constraint.layout;
|
|
layout36.horizontalWeight = typedArray.getFloat(index, layout36.horizontalWeight);
|
|
break;
|
|
case 40:
|
|
Layout layout37 = constraint.layout;
|
|
layout37.verticalWeight = typedArray.getFloat(index, layout37.verticalWeight);
|
|
break;
|
|
case 41:
|
|
Layout layout38 = constraint.layout;
|
|
layout38.horizontalChainStyle = typedArray.getInt(index, layout38.horizontalChainStyle);
|
|
break;
|
|
case 42:
|
|
Layout layout39 = constraint.layout;
|
|
layout39.verticalChainStyle = typedArray.getInt(index, layout39.verticalChainStyle);
|
|
break;
|
|
case 43:
|
|
PropertySet propertySet3 = constraint.propertySet;
|
|
propertySet3.alpha = typedArray.getFloat(index, propertySet3.alpha);
|
|
break;
|
|
case 44:
|
|
Transform transform = constraint.transform;
|
|
transform.applyElevation = true;
|
|
transform.elevation = typedArray.getDimension(index, transform.elevation);
|
|
break;
|
|
case 45:
|
|
Transform transform2 = constraint.transform;
|
|
transform2.rotationX = typedArray.getFloat(index, transform2.rotationX);
|
|
break;
|
|
case 46:
|
|
Transform transform3 = constraint.transform;
|
|
transform3.rotationY = typedArray.getFloat(index, transform3.rotationY);
|
|
break;
|
|
case 47:
|
|
Transform transform4 = constraint.transform;
|
|
transform4.scaleX = typedArray.getFloat(index, transform4.scaleX);
|
|
break;
|
|
case 48:
|
|
Transform transform5 = constraint.transform;
|
|
transform5.scaleY = typedArray.getFloat(index, transform5.scaleY);
|
|
break;
|
|
case 49:
|
|
Transform transform6 = constraint.transform;
|
|
transform6.transformPivotX = typedArray.getDimension(index, transform6.transformPivotX);
|
|
break;
|
|
case 50:
|
|
Transform transform7 = constraint.transform;
|
|
transform7.transformPivotY = typedArray.getDimension(index, transform7.transformPivotY);
|
|
break;
|
|
case 51:
|
|
Transform transform8 = constraint.transform;
|
|
transform8.translationX = typedArray.getDimension(index, transform8.translationX);
|
|
break;
|
|
case 52:
|
|
Transform transform9 = constraint.transform;
|
|
transform9.translationY = typedArray.getDimension(index, transform9.translationY);
|
|
break;
|
|
case 53:
|
|
Transform transform10 = constraint.transform;
|
|
transform10.translationZ = typedArray.getDimension(index, transform10.translationZ);
|
|
break;
|
|
case 54:
|
|
Layout layout40 = constraint.layout;
|
|
layout40.widthDefault = typedArray.getInt(index, layout40.widthDefault);
|
|
break;
|
|
case 55:
|
|
Layout layout41 = constraint.layout;
|
|
layout41.heightDefault = typedArray.getInt(index, layout41.heightDefault);
|
|
break;
|
|
case 56:
|
|
Layout layout42 = constraint.layout;
|
|
layout42.widthMax = typedArray.getDimensionPixelSize(index, layout42.widthMax);
|
|
break;
|
|
case 57:
|
|
Layout layout43 = constraint.layout;
|
|
layout43.heightMax = typedArray.getDimensionPixelSize(index, layout43.heightMax);
|
|
break;
|
|
case 58:
|
|
Layout layout44 = constraint.layout;
|
|
layout44.widthMin = typedArray.getDimensionPixelSize(index, layout44.widthMin);
|
|
break;
|
|
case 59:
|
|
Layout layout45 = constraint.layout;
|
|
layout45.heightMin = typedArray.getDimensionPixelSize(index, layout45.heightMin);
|
|
break;
|
|
case 60:
|
|
Transform transform11 = constraint.transform;
|
|
transform11.rotation = typedArray.getFloat(index, transform11.rotation);
|
|
break;
|
|
case 61:
|
|
Layout layout46 = constraint.layout;
|
|
layout46.circleConstraint = lookupID(typedArray, index, layout46.circleConstraint);
|
|
break;
|
|
case 62:
|
|
Layout layout47 = constraint.layout;
|
|
layout47.circleRadius = typedArray.getDimensionPixelSize(index, layout47.circleRadius);
|
|
break;
|
|
case 63:
|
|
Layout layout48 = constraint.layout;
|
|
layout48.circleAngle = typedArray.getFloat(index, layout48.circleAngle);
|
|
break;
|
|
case 64:
|
|
Motion motion = constraint.motion;
|
|
motion.mAnimateRelativeTo = lookupID(typedArray, index, motion.mAnimateRelativeTo);
|
|
break;
|
|
case 65:
|
|
if (typedArray.peekValue(index).type == 3) {
|
|
constraint.motion.mTransitionEasing = typedArray.getString(index);
|
|
break;
|
|
} else {
|
|
constraint.motion.mTransitionEasing = Easing.NAMED_EASING[typedArray.getInteger(index, 0)];
|
|
break;
|
|
}
|
|
case 66:
|
|
constraint.motion.mDrawPath = typedArray.getInt(index, 0);
|
|
break;
|
|
case 67:
|
|
Motion motion2 = constraint.motion;
|
|
motion2.mPathRotate = typedArray.getFloat(index, motion2.mPathRotate);
|
|
break;
|
|
case 68:
|
|
PropertySet propertySet4 = constraint.propertySet;
|
|
propertySet4.mProgress = typedArray.getFloat(index, propertySet4.mProgress);
|
|
break;
|
|
case 69:
|
|
constraint.layout.widthPercent = typedArray.getFloat(index, 1.0f);
|
|
break;
|
|
case 70:
|
|
constraint.layout.heightPercent = typedArray.getFloat(index, 1.0f);
|
|
break;
|
|
case 71:
|
|
Log.e(TAG, "CURRENTLY UNSUPPORTED");
|
|
break;
|
|
case 72:
|
|
Layout layout49 = constraint.layout;
|
|
layout49.mBarrierDirection = typedArray.getInt(index, layout49.mBarrierDirection);
|
|
break;
|
|
case 73:
|
|
Layout layout50 = constraint.layout;
|
|
layout50.mBarrierMargin = typedArray.getDimensionPixelSize(index, layout50.mBarrierMargin);
|
|
break;
|
|
case 74:
|
|
constraint.layout.mReferenceIdString = typedArray.getString(index);
|
|
break;
|
|
case 75:
|
|
Layout layout51 = constraint.layout;
|
|
layout51.mBarrierAllowsGoneWidgets = typedArray.getBoolean(index, layout51.mBarrierAllowsGoneWidgets);
|
|
break;
|
|
case 76:
|
|
Motion motion3 = constraint.motion;
|
|
motion3.mPathMotionArc = typedArray.getInt(index, motion3.mPathMotionArc);
|
|
break;
|
|
case 77:
|
|
constraint.layout.mConstraintTag = typedArray.getString(index);
|
|
break;
|
|
case 78:
|
|
PropertySet propertySet5 = constraint.propertySet;
|
|
propertySet5.mVisibilityMode = typedArray.getInt(index, propertySet5.mVisibilityMode);
|
|
break;
|
|
case 79:
|
|
Motion motion4 = constraint.motion;
|
|
motion4.mMotionStagger = typedArray.getFloat(index, motion4.mMotionStagger);
|
|
break;
|
|
case 80:
|
|
Layout layout52 = constraint.layout;
|
|
layout52.constrainedWidth = typedArray.getBoolean(index, layout52.constrainedWidth);
|
|
break;
|
|
case 81:
|
|
Layout layout53 = constraint.layout;
|
|
layout53.constrainedHeight = typedArray.getBoolean(index, layout53.constrainedHeight);
|
|
break;
|
|
case 82:
|
|
StringBuilder L = a.L("unused attribute 0x");
|
|
L.append(Integer.toHexString(index));
|
|
L.append(" ");
|
|
L.append(mapToConstant.get(index));
|
|
Log.w(TAG, L.toString());
|
|
break;
|
|
default:
|
|
StringBuilder L2 = a.L("Unknown attribute 0x");
|
|
L2.append(Integer.toHexString(index));
|
|
L2.append(" ");
|
|
L2.append(mapToConstant.get(index));
|
|
Log.w(TAG, L2.toString());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private String sideToString(int i) {
|
|
switch (i) {
|
|
case 1:
|
|
return "left";
|
|
case 2:
|
|
return "right";
|
|
case 3:
|
|
return "top";
|
|
case 4:
|
|
return "bottom";
|
|
case 5:
|
|
return "baseline";
|
|
case 6:
|
|
return "start";
|
|
case 7:
|
|
return "end";
|
|
default:
|
|
return "undefined";
|
|
}
|
|
}
|
|
|
|
private static String[] splitString(String str) {
|
|
char[] charArray = str.toCharArray();
|
|
ArrayList arrayList = new ArrayList();
|
|
int i = 0;
|
|
boolean z2 = false;
|
|
for (int i2 = 0; i2 < charArray.length; i2++) {
|
|
if (charArray[i2] == ',' && !z2) {
|
|
arrayList.add(new String(charArray, i, i2 - i));
|
|
i = i2 + 1;
|
|
} else if (charArray[i2] == '\"') {
|
|
z2 = !z2;
|
|
}
|
|
}
|
|
arrayList.add(new String(charArray, i, charArray.length - i));
|
|
return (String[]) arrayList.toArray(new String[arrayList.size()]);
|
|
}
|
|
|
|
public void addColorAttributes(String... strArr) {
|
|
addAttributes(ConstraintAttribute.AttributeType.COLOR_TYPE, strArr);
|
|
}
|
|
|
|
public void addFloatAttributes(String... strArr) {
|
|
addAttributes(ConstraintAttribute.AttributeType.FLOAT_TYPE, strArr);
|
|
}
|
|
|
|
public void addIntAttributes(String... strArr) {
|
|
addAttributes(ConstraintAttribute.AttributeType.INT_TYPE, strArr);
|
|
}
|
|
|
|
public void addStringAttributes(String... strArr) {
|
|
addAttributes(ConstraintAttribute.AttributeType.STRING_TYPE, strArr);
|
|
}
|
|
|
|
public void addToHorizontalChain(int i, int i2, int i3) {
|
|
connect(i, 1, i2, i2 == 0 ? 1 : 2, 0);
|
|
connect(i, 2, i3, i3 == 0 ? 2 : 1, 0);
|
|
if (i2 != 0) {
|
|
connect(i2, 2, i, 1, 0);
|
|
}
|
|
if (i3 != 0) {
|
|
connect(i3, 1, i, 2, 0);
|
|
}
|
|
}
|
|
|
|
public void addToHorizontalChainRTL(int i, int i2, int i3) {
|
|
connect(i, 6, i2, i2 == 0 ? 6 : 7, 0);
|
|
connect(i, 7, i3, i3 == 0 ? 7 : 6, 0);
|
|
if (i2 != 0) {
|
|
connect(i2, 7, i, 6, 0);
|
|
}
|
|
if (i3 != 0) {
|
|
connect(i3, 6, i, 7, 0);
|
|
}
|
|
}
|
|
|
|
public void addToVerticalChain(int i, int i2, int i3) {
|
|
connect(i, 3, i2, i2 == 0 ? 3 : 4, 0);
|
|
connect(i, 4, i3, i3 == 0 ? 4 : 3, 0);
|
|
if (i2 != 0) {
|
|
connect(i2, 4, i, 3, 0);
|
|
}
|
|
if (i3 != 0) {
|
|
connect(i3, 3, i, 4, 0);
|
|
}
|
|
}
|
|
|
|
public void applyCustomAttributes(ConstraintLayout constraintLayout) {
|
|
int childCount = constraintLayout.getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = constraintLayout.getChildAt(i);
|
|
int id2 = childAt.getId();
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
StringBuilder L = a.L("id unknown ");
|
|
L.append(Debug.getName(childAt));
|
|
Log.v(TAG, L.toString());
|
|
} else if (this.mForceId && id2 == -1) {
|
|
throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
|
|
} else if (this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
ConstraintAttribute.setAttributes(childAt, this.mConstraints.get(Integer.valueOf(id2)).mCustomConstraints);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void applyTo(ConstraintLayout constraintLayout) {
|
|
applyToInternal(constraintLayout, true);
|
|
constraintLayout.setConstraintSet(null);
|
|
constraintLayout.requestLayout();
|
|
}
|
|
|
|
public void applyToHelper(ConstraintHelper constraintHelper, ConstraintWidget constraintWidget, ConstraintLayout.LayoutParams layoutParams, SparseArray<ConstraintWidget> sparseArray) {
|
|
int id2 = constraintHelper.getId();
|
|
if (this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(id2));
|
|
if (constraintWidget instanceof HelperWidget) {
|
|
constraintHelper.loadParameters(constraint, (HelperWidget) constraintWidget, layoutParams, sparseArray);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void applyToInternal(ConstraintLayout constraintLayout, boolean z2) {
|
|
int childCount = constraintLayout.getChildCount();
|
|
HashSet hashSet = new HashSet(this.mConstraints.keySet());
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = constraintLayout.getChildAt(i);
|
|
int id2 = childAt.getId();
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
StringBuilder L = a.L("id unknown ");
|
|
L.append(Debug.getName(childAt));
|
|
Log.w(TAG, L.toString());
|
|
} else if (this.mForceId && id2 == -1) {
|
|
throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
|
|
} else if (id2 != -1) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
hashSet.remove(Integer.valueOf(id2));
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(id2));
|
|
if (childAt instanceof Barrier) {
|
|
constraint.layout.mHelperType = 1;
|
|
}
|
|
int i2 = constraint.layout.mHelperType;
|
|
if (i2 != -1 && i2 == 1) {
|
|
Barrier barrier = (Barrier) childAt;
|
|
barrier.setId(id2);
|
|
barrier.setType(constraint.layout.mBarrierDirection);
|
|
barrier.setMargin(constraint.layout.mBarrierMargin);
|
|
barrier.setAllowsGoneWidget(constraint.layout.mBarrierAllowsGoneWidgets);
|
|
Layout layout = constraint.layout;
|
|
int[] iArr = layout.mReferenceIds;
|
|
if (iArr != null) {
|
|
barrier.setReferencedIds(iArr);
|
|
} else {
|
|
String str = layout.mReferenceIdString;
|
|
if (str != null) {
|
|
layout.mReferenceIds = convertReferenceString(barrier, str);
|
|
barrier.setReferencedIds(constraint.layout.mReferenceIds);
|
|
}
|
|
}
|
|
}
|
|
ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) childAt.getLayoutParams();
|
|
layoutParams.validate();
|
|
constraint.applyTo(layoutParams);
|
|
if (z2) {
|
|
ConstraintAttribute.setAttributes(childAt, constraint.mCustomConstraints);
|
|
}
|
|
childAt.setLayoutParams(layoutParams);
|
|
PropertySet propertySet = constraint.propertySet;
|
|
if (propertySet.mVisibilityMode == 0) {
|
|
childAt.setVisibility(propertySet.visibility);
|
|
}
|
|
childAt.setAlpha(constraint.propertySet.alpha);
|
|
childAt.setRotation(constraint.transform.rotation);
|
|
childAt.setRotationX(constraint.transform.rotationX);
|
|
childAt.setRotationY(constraint.transform.rotationY);
|
|
childAt.setScaleX(constraint.transform.scaleX);
|
|
childAt.setScaleY(constraint.transform.scaleY);
|
|
if (!Float.isNaN(constraint.transform.transformPivotX)) {
|
|
childAt.setPivotX(constraint.transform.transformPivotX);
|
|
}
|
|
if (!Float.isNaN(constraint.transform.transformPivotY)) {
|
|
childAt.setPivotY(constraint.transform.transformPivotY);
|
|
}
|
|
childAt.setTranslationX(constraint.transform.translationX);
|
|
childAt.setTranslationY(constraint.transform.translationY);
|
|
childAt.setTranslationZ(constraint.transform.translationZ);
|
|
Transform transform = constraint.transform;
|
|
if (transform.applyElevation) {
|
|
childAt.setElevation(transform.elevation);
|
|
}
|
|
} else {
|
|
Log.v(TAG, "WARNING NO CONSTRAINTS for view " + id2);
|
|
}
|
|
}
|
|
}
|
|
Iterator it = hashSet.iterator();
|
|
while (it.hasNext()) {
|
|
Integer num = (Integer) it.next();
|
|
Constraint constraint2 = this.mConstraints.get(num);
|
|
int i3 = constraint2.layout.mHelperType;
|
|
if (i3 != -1 && i3 == 1) {
|
|
Barrier barrier2 = new Barrier(constraintLayout.getContext());
|
|
barrier2.setId(num.intValue());
|
|
Layout layout2 = constraint2.layout;
|
|
int[] iArr2 = layout2.mReferenceIds;
|
|
if (iArr2 != null) {
|
|
barrier2.setReferencedIds(iArr2);
|
|
} else {
|
|
String str2 = layout2.mReferenceIdString;
|
|
if (str2 != null) {
|
|
layout2.mReferenceIds = convertReferenceString(barrier2, str2);
|
|
barrier2.setReferencedIds(constraint2.layout.mReferenceIds);
|
|
}
|
|
}
|
|
barrier2.setType(constraint2.layout.mBarrierDirection);
|
|
barrier2.setMargin(constraint2.layout.mBarrierMargin);
|
|
ConstraintLayout.LayoutParams generateDefaultLayoutParams = constraintLayout.generateDefaultLayoutParams();
|
|
barrier2.validateParams();
|
|
constraint2.applyTo(generateDefaultLayoutParams);
|
|
constraintLayout.addView(barrier2, generateDefaultLayoutParams);
|
|
}
|
|
if (constraint2.layout.mIsGuideline) {
|
|
View guideline = new Guideline(constraintLayout.getContext());
|
|
guideline.setId(num.intValue());
|
|
ConstraintLayout.LayoutParams generateDefaultLayoutParams2 = constraintLayout.generateDefaultLayoutParams();
|
|
constraint2.applyTo(generateDefaultLayoutParams2);
|
|
constraintLayout.addView(guideline, generateDefaultLayoutParams2);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void applyToLayoutParams(int i, ConstraintLayout.LayoutParams layoutParams) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
this.mConstraints.get(Integer.valueOf(i)).applyTo(layoutParams);
|
|
}
|
|
}
|
|
|
|
public void applyToWithoutCustom(ConstraintLayout constraintLayout) {
|
|
applyToInternal(constraintLayout, false);
|
|
constraintLayout.setConstraintSet(null);
|
|
}
|
|
|
|
public void center(int i, int i2, int i3, int i4, int i5, int i6, int i7, float f) {
|
|
if (i4 < 0) {
|
|
throw new IllegalArgumentException("margin must be > 0");
|
|
} else if (i7 < 0) {
|
|
throw new IllegalArgumentException("margin must be > 0");
|
|
} else if (f <= 0.0f || f > 1.0f) {
|
|
throw new IllegalArgumentException("bias must be between 0 and 1 inclusive");
|
|
} else if (i3 == 1 || i3 == 2) {
|
|
connect(i, 1, i2, i3, i4);
|
|
connect(i, 2, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.horizontalBias = f;
|
|
} else if (i3 == 6 || i3 == 7) {
|
|
connect(i, 6, i2, i3, i4);
|
|
connect(i, 7, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.horizontalBias = f;
|
|
} else {
|
|
connect(i, 3, i2, i3, i4);
|
|
connect(i, 4, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.verticalBias = f;
|
|
}
|
|
}
|
|
|
|
public void centerHorizontally(int i, int i2) {
|
|
if (i2 == 0) {
|
|
center(i, 0, 1, 0, 0, 2, 0, 0.5f);
|
|
} else {
|
|
center(i, i2, 2, 0, i2, 1, 0, 0.5f);
|
|
}
|
|
}
|
|
|
|
public void centerHorizontally(int i, int i2, int i3, int i4, int i5, int i6, int i7, float f) {
|
|
connect(i, 1, i2, i3, i4);
|
|
connect(i, 2, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.horizontalBias = f;
|
|
}
|
|
|
|
public void centerHorizontallyRtl(int i, int i2) {
|
|
if (i2 == 0) {
|
|
center(i, 0, 6, 0, 0, 7, 0, 0.5f);
|
|
} else {
|
|
center(i, i2, 7, 0, i2, 6, 0, 0.5f);
|
|
}
|
|
}
|
|
|
|
public void centerHorizontallyRtl(int i, int i2, int i3, int i4, int i5, int i6, int i7, float f) {
|
|
connect(i, 6, i2, i3, i4);
|
|
connect(i, 7, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.horizontalBias = f;
|
|
}
|
|
|
|
public void centerVertically(int i, int i2) {
|
|
if (i2 == 0) {
|
|
center(i, 0, 3, 0, 0, 4, 0, 0.5f);
|
|
} else {
|
|
center(i, i2, 4, 0, i2, 3, 0, 0.5f);
|
|
}
|
|
}
|
|
|
|
public void centerVertically(int i, int i2, int i3, int i4, int i5, int i6, int i7, float f) {
|
|
connect(i, 3, i2, i3, i4);
|
|
connect(i, 4, i5, i6, i7);
|
|
this.mConstraints.get(Integer.valueOf(i)).layout.verticalBias = f;
|
|
}
|
|
|
|
public void clear(int i) {
|
|
this.mConstraints.remove(Integer.valueOf(i));
|
|
}
|
|
|
|
public void clear(int i, int i2) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(i));
|
|
switch (i2) {
|
|
case 1:
|
|
Layout layout = constraint.layout;
|
|
layout.leftToRight = -1;
|
|
layout.leftToLeft = -1;
|
|
layout.leftMargin = -1;
|
|
layout.goneLeftMargin = -1;
|
|
return;
|
|
case 2:
|
|
Layout layout2 = constraint.layout;
|
|
layout2.rightToRight = -1;
|
|
layout2.rightToLeft = -1;
|
|
layout2.rightMargin = -1;
|
|
layout2.goneRightMargin = -1;
|
|
return;
|
|
case 3:
|
|
Layout layout3 = constraint.layout;
|
|
layout3.topToBottom = -1;
|
|
layout3.topToTop = -1;
|
|
layout3.topMargin = -1;
|
|
layout3.goneTopMargin = -1;
|
|
return;
|
|
case 4:
|
|
Layout layout4 = constraint.layout;
|
|
layout4.bottomToTop = -1;
|
|
layout4.bottomToBottom = -1;
|
|
layout4.bottomMargin = -1;
|
|
layout4.goneBottomMargin = -1;
|
|
return;
|
|
case 5:
|
|
constraint.layout.baselineToBaseline = -1;
|
|
return;
|
|
case 6:
|
|
Layout layout5 = constraint.layout;
|
|
layout5.startToEnd = -1;
|
|
layout5.startToStart = -1;
|
|
layout5.startMargin = -1;
|
|
layout5.goneStartMargin = -1;
|
|
return;
|
|
case 7:
|
|
Layout layout6 = constraint.layout;
|
|
layout6.endToStart = -1;
|
|
layout6.endToEnd = -1;
|
|
layout6.endMargin = -1;
|
|
layout6.goneEndMargin = -1;
|
|
return;
|
|
default:
|
|
throw new IllegalArgumentException("unknown constraint");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void clone(Context context, int i) {
|
|
clone((ConstraintLayout) LayoutInflater.from(context).inflate(i, (ViewGroup) null));
|
|
}
|
|
|
|
public void clone(ConstraintLayout constraintLayout) {
|
|
int childCount = constraintLayout.getChildCount();
|
|
this.mConstraints.clear();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = constraintLayout.getChildAt(i);
|
|
ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) childAt.getLayoutParams();
|
|
int id2 = childAt.getId();
|
|
if (!this.mForceId || id2 != -1) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
this.mConstraints.put(Integer.valueOf(id2), new Constraint());
|
|
}
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(id2));
|
|
constraint.mCustomConstraints = ConstraintAttribute.extractAttributes(this.mSavedAttributes, childAt);
|
|
Constraint.access$000(constraint, id2, layoutParams);
|
|
constraint.propertySet.visibility = childAt.getVisibility();
|
|
constraint.propertySet.alpha = childAt.getAlpha();
|
|
constraint.transform.rotation = childAt.getRotation();
|
|
constraint.transform.rotationX = childAt.getRotationX();
|
|
constraint.transform.rotationY = childAt.getRotationY();
|
|
constraint.transform.scaleX = childAt.getScaleX();
|
|
constraint.transform.scaleY = childAt.getScaleY();
|
|
float pivotX = childAt.getPivotX();
|
|
float pivotY = childAt.getPivotY();
|
|
if (!(((double) pivotX) == ShadowDrawableWrapper.COS_45 && ((double) pivotY) == ShadowDrawableWrapper.COS_45)) {
|
|
Transform transform = constraint.transform;
|
|
transform.transformPivotX = pivotX;
|
|
transform.transformPivotY = pivotY;
|
|
}
|
|
constraint.transform.translationX = childAt.getTranslationX();
|
|
constraint.transform.translationY = childAt.getTranslationY();
|
|
constraint.transform.translationZ = childAt.getTranslationZ();
|
|
Transform transform2 = constraint.transform;
|
|
if (transform2.applyElevation) {
|
|
transform2.elevation = childAt.getElevation();
|
|
}
|
|
if (childAt instanceof Barrier) {
|
|
Barrier barrier = (Barrier) childAt;
|
|
constraint.layout.mBarrierAllowsGoneWidgets = barrier.allowsGoneWidget();
|
|
constraint.layout.mReferenceIds = barrier.getReferencedIds();
|
|
constraint.layout.mBarrierDirection = barrier.getType();
|
|
constraint.layout.mBarrierMargin = barrier.getMargin();
|
|
}
|
|
} else {
|
|
throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void clone(ConstraintSet constraintSet) {
|
|
this.mConstraints.clear();
|
|
for (Integer num : constraintSet.mConstraints.keySet()) {
|
|
this.mConstraints.put(num, constraintSet.mConstraints.get(num).clone());
|
|
}
|
|
}
|
|
|
|
public void clone(Constraints constraints) {
|
|
int childCount = constraints.getChildCount();
|
|
this.mConstraints.clear();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = constraints.getChildAt(i);
|
|
Constraints.LayoutParams layoutParams = (Constraints.LayoutParams) childAt.getLayoutParams();
|
|
int id2 = childAt.getId();
|
|
if (!this.mForceId || id2 != -1) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
this.mConstraints.put(Integer.valueOf(id2), new Constraint());
|
|
}
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(id2));
|
|
if (childAt instanceof ConstraintHelper) {
|
|
Constraint.access$300(constraint, (ConstraintHelper) childAt, id2, layoutParams);
|
|
}
|
|
Constraint.access$400(constraint, id2, layoutParams);
|
|
} else {
|
|
throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void connect(int i, int i2, int i3, int i4) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
this.mConstraints.put(Integer.valueOf(i), new Constraint());
|
|
}
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(i));
|
|
switch (i2) {
|
|
case 1:
|
|
if (i4 == 1) {
|
|
Layout layout = constraint.layout;
|
|
layout.leftToLeft = i3;
|
|
layout.leftToRight = -1;
|
|
return;
|
|
} else if (i4 == 2) {
|
|
Layout layout2 = constraint.layout;
|
|
layout2.leftToRight = i3;
|
|
layout2.leftToLeft = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("left to "), sideToString(i4), " undefined"));
|
|
}
|
|
case 2:
|
|
if (i4 == 1) {
|
|
Layout layout3 = constraint.layout;
|
|
layout3.rightToLeft = i3;
|
|
layout3.rightToRight = -1;
|
|
return;
|
|
} else if (i4 == 2) {
|
|
Layout layout4 = constraint.layout;
|
|
layout4.rightToRight = i3;
|
|
layout4.rightToLeft = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
case 3:
|
|
if (i4 == 3) {
|
|
Layout layout5 = constraint.layout;
|
|
layout5.topToTop = i3;
|
|
layout5.topToBottom = -1;
|
|
layout5.baselineToBaseline = -1;
|
|
return;
|
|
} else if (i4 == 4) {
|
|
Layout layout6 = constraint.layout;
|
|
layout6.topToBottom = i3;
|
|
layout6.topToTop = -1;
|
|
layout6.baselineToBaseline = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
case 4:
|
|
if (i4 == 4) {
|
|
Layout layout7 = constraint.layout;
|
|
layout7.bottomToBottom = i3;
|
|
layout7.bottomToTop = -1;
|
|
layout7.baselineToBaseline = -1;
|
|
return;
|
|
} else if (i4 == 3) {
|
|
Layout layout8 = constraint.layout;
|
|
layout8.bottomToTop = i3;
|
|
layout8.bottomToBottom = -1;
|
|
layout8.baselineToBaseline = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
case 5:
|
|
if (i4 == 5) {
|
|
Layout layout9 = constraint.layout;
|
|
layout9.baselineToBaseline = i3;
|
|
layout9.bottomToBottom = -1;
|
|
layout9.bottomToTop = -1;
|
|
layout9.topToTop = -1;
|
|
layout9.topToBottom = -1;
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
case 6:
|
|
if (i4 == 6) {
|
|
Layout layout10 = constraint.layout;
|
|
layout10.startToStart = i3;
|
|
layout10.startToEnd = -1;
|
|
return;
|
|
} else if (i4 == 7) {
|
|
Layout layout11 = constraint.layout;
|
|
layout11.startToEnd = i3;
|
|
layout11.startToStart = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
case 7:
|
|
if (i4 == 7) {
|
|
Layout layout12 = constraint.layout;
|
|
layout12.endToEnd = i3;
|
|
layout12.endToStart = -1;
|
|
return;
|
|
} else if (i4 == 6) {
|
|
Layout layout13 = constraint.layout;
|
|
layout13.endToStart = i3;
|
|
layout13.endToEnd = -1;
|
|
return;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
default:
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(sideToString(i2));
|
|
sb.append(" to ");
|
|
throw new IllegalArgumentException(a.D(sb, sideToString(i4), " unknown"));
|
|
}
|
|
}
|
|
|
|
public void connect(int i, int i2, int i3, int i4, int i5) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
this.mConstraints.put(Integer.valueOf(i), new Constraint());
|
|
}
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(i));
|
|
switch (i2) {
|
|
case 1:
|
|
if (i4 == 1) {
|
|
Layout layout = constraint.layout;
|
|
layout.leftToLeft = i3;
|
|
layout.leftToRight = -1;
|
|
} else if (i4 == 2) {
|
|
Layout layout2 = constraint.layout;
|
|
layout2.leftToRight = i3;
|
|
layout2.leftToLeft = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("Left to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.leftMargin = i5;
|
|
return;
|
|
case 2:
|
|
if (i4 == 1) {
|
|
Layout layout3 = constraint.layout;
|
|
layout3.rightToLeft = i3;
|
|
layout3.rightToRight = -1;
|
|
} else if (i4 == 2) {
|
|
Layout layout4 = constraint.layout;
|
|
layout4.rightToRight = i3;
|
|
layout4.rightToLeft = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.rightMargin = i5;
|
|
return;
|
|
case 3:
|
|
if (i4 == 3) {
|
|
Layout layout5 = constraint.layout;
|
|
layout5.topToTop = i3;
|
|
layout5.topToBottom = -1;
|
|
layout5.baselineToBaseline = -1;
|
|
} else if (i4 == 4) {
|
|
Layout layout6 = constraint.layout;
|
|
layout6.topToBottom = i3;
|
|
layout6.topToTop = -1;
|
|
layout6.baselineToBaseline = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.topMargin = i5;
|
|
return;
|
|
case 4:
|
|
if (i4 == 4) {
|
|
Layout layout7 = constraint.layout;
|
|
layout7.bottomToBottom = i3;
|
|
layout7.bottomToTop = -1;
|
|
layout7.baselineToBaseline = -1;
|
|
} else if (i4 == 3) {
|
|
Layout layout8 = constraint.layout;
|
|
layout8.bottomToTop = i3;
|
|
layout8.bottomToBottom = -1;
|
|
layout8.baselineToBaseline = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.bottomMargin = i5;
|
|
return;
|
|
case 5:
|
|
if (i4 == 5) {
|
|
Layout layout9 = constraint.layout;
|
|
layout9.baselineToBaseline = i3;
|
|
layout9.bottomToBottom = -1;
|
|
layout9.bottomToTop = -1;
|
|
layout9.topToTop = -1;
|
|
layout9.topToBottom = -1;
|
|
return;
|
|
}
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
case 6:
|
|
if (i4 == 6) {
|
|
Layout layout10 = constraint.layout;
|
|
layout10.startToStart = i3;
|
|
layout10.startToEnd = -1;
|
|
} else if (i4 == 7) {
|
|
Layout layout11 = constraint.layout;
|
|
layout11.startToEnd = i3;
|
|
layout11.startToStart = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.startMargin = i5;
|
|
return;
|
|
case 7:
|
|
if (i4 == 7) {
|
|
Layout layout12 = constraint.layout;
|
|
layout12.endToEnd = i3;
|
|
layout12.endToStart = -1;
|
|
} else if (i4 == 6) {
|
|
Layout layout13 = constraint.layout;
|
|
layout13.endToStart = i3;
|
|
layout13.endToEnd = -1;
|
|
} else {
|
|
throw new IllegalArgumentException(a.D(a.L("right to "), sideToString(i4), " undefined"));
|
|
}
|
|
constraint.layout.endMargin = i5;
|
|
return;
|
|
default:
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append(sideToString(i2));
|
|
sb.append(" to ");
|
|
throw new IllegalArgumentException(a.D(sb, sideToString(i4), " unknown"));
|
|
}
|
|
}
|
|
|
|
public void constrainCircle(int i, int i2, int i3, float f) {
|
|
Layout layout = get(i).layout;
|
|
layout.circleConstraint = i2;
|
|
layout.circleRadius = i3;
|
|
layout.circleAngle = f;
|
|
}
|
|
|
|
public void constrainDefaultHeight(int i, int i2) {
|
|
get(i).layout.heightDefault = i2;
|
|
}
|
|
|
|
public void constrainDefaultWidth(int i, int i2) {
|
|
get(i).layout.widthDefault = i2;
|
|
}
|
|
|
|
public void constrainHeight(int i, int i2) {
|
|
get(i).layout.mHeight = i2;
|
|
}
|
|
|
|
public void constrainMaxHeight(int i, int i2) {
|
|
get(i).layout.heightMax = i2;
|
|
}
|
|
|
|
public void constrainMaxWidth(int i, int i2) {
|
|
get(i).layout.widthMax = i2;
|
|
}
|
|
|
|
public void constrainMinHeight(int i, int i2) {
|
|
get(i).layout.heightMin = i2;
|
|
}
|
|
|
|
public void constrainMinWidth(int i, int i2) {
|
|
get(i).layout.widthMin = i2;
|
|
}
|
|
|
|
public void constrainPercentHeight(int i, float f) {
|
|
get(i).layout.heightPercent = f;
|
|
}
|
|
|
|
public void constrainPercentWidth(int i, float f) {
|
|
get(i).layout.widthPercent = f;
|
|
}
|
|
|
|
public void constrainWidth(int i, int i2) {
|
|
get(i).layout.mWidth = i2;
|
|
}
|
|
|
|
public void constrainedHeight(int i, boolean z2) {
|
|
get(i).layout.constrainedHeight = z2;
|
|
}
|
|
|
|
public void constrainedWidth(int i, boolean z2) {
|
|
get(i).layout.constrainedWidth = z2;
|
|
}
|
|
|
|
public void create(int i, int i2) {
|
|
Layout layout = get(i).layout;
|
|
layout.mIsGuideline = true;
|
|
layout.orientation = i2;
|
|
}
|
|
|
|
public void createBarrier(int i, int i2, int i3, int... iArr) {
|
|
Layout layout = get(i).layout;
|
|
layout.mHelperType = 1;
|
|
layout.mBarrierDirection = i2;
|
|
layout.mBarrierMargin = i3;
|
|
layout.mIsGuideline = false;
|
|
layout.mReferenceIds = iArr;
|
|
}
|
|
|
|
public void createHorizontalChain(int i, int i2, int i3, int i4, int[] iArr, float[] fArr, int i5) {
|
|
createHorizontalChain(i, i2, i3, i4, iArr, fArr, i5, 1, 2);
|
|
}
|
|
|
|
public void createHorizontalChainRtl(int i, int i2, int i3, int i4, int[] iArr, float[] fArr, int i5) {
|
|
createHorizontalChain(i, i2, i3, i4, iArr, fArr, i5, 6, 7);
|
|
}
|
|
|
|
public void createVerticalChain(int i, int i2, int i3, int i4, int[] iArr, float[] fArr, int i5) {
|
|
if (iArr.length < 2) {
|
|
throw new IllegalArgumentException("must have 2 or more widgets in a chain");
|
|
} else if (fArr == null || fArr.length == iArr.length) {
|
|
if (fArr != null) {
|
|
get(iArr[0]).layout.verticalWeight = fArr[0];
|
|
}
|
|
get(iArr[0]).layout.verticalChainStyle = i5;
|
|
connect(iArr[0], 3, i, i2, 0);
|
|
for (int i6 = 1; i6 < iArr.length; i6++) {
|
|
int i7 = iArr[i6];
|
|
int i8 = i6 - 1;
|
|
connect(iArr[i6], 3, iArr[i8], 4, 0);
|
|
connect(iArr[i8], 4, iArr[i6], 3, 0);
|
|
if (fArr != null) {
|
|
get(iArr[i6]).layout.verticalWeight = fArr[i6];
|
|
}
|
|
}
|
|
connect(iArr[iArr.length - 1], 4, i3, i4, 0);
|
|
} else {
|
|
throw new IllegalArgumentException("must have 2 or more widgets in a chain");
|
|
}
|
|
}
|
|
|
|
public void dump(MotionScene motionScene, int... iArr) {
|
|
HashSet hashSet;
|
|
Set<Integer> keySet = this.mConstraints.keySet();
|
|
if (iArr.length != 0) {
|
|
hashSet = new HashSet();
|
|
for (int i : iArr) {
|
|
hashSet.add(Integer.valueOf(i));
|
|
}
|
|
} else {
|
|
hashSet = new HashSet(keySet);
|
|
}
|
|
System.out.println(hashSet.size() + " constraints");
|
|
StringBuilder sb = new StringBuilder();
|
|
Integer[] numArr = (Integer[]) hashSet.toArray(new Integer[0]);
|
|
for (Integer num : numArr) {
|
|
sb.append("<Constraint id=");
|
|
sb.append(num);
|
|
sb.append(" \n");
|
|
this.mConstraints.get(num).layout.dump(motionScene, sb);
|
|
sb.append("/>\n");
|
|
}
|
|
System.out.println(sb.toString());
|
|
}
|
|
|
|
public boolean getApplyElevation(int i) {
|
|
return get(i).transform.applyElevation;
|
|
}
|
|
|
|
public Constraint getConstraint(int i) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
return this.mConstraints.get(Integer.valueOf(i));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public HashMap<String, ConstraintAttribute> getCustomAttributeSet() {
|
|
return this.mSavedAttributes;
|
|
}
|
|
|
|
public int getHeight(int i) {
|
|
return get(i).layout.mHeight;
|
|
}
|
|
|
|
public int[] getKnownIds() {
|
|
Integer[] numArr = (Integer[]) this.mConstraints.keySet().toArray(new Integer[0]);
|
|
int length = numArr.length;
|
|
int[] iArr = new int[length];
|
|
for (int i = 0; i < length; i++) {
|
|
iArr[i] = numArr[i].intValue();
|
|
}
|
|
return iArr;
|
|
}
|
|
|
|
public Constraint getParameters(int i) {
|
|
return get(i);
|
|
}
|
|
|
|
public int[] getReferencedIds(int i) {
|
|
int[] iArr = get(i).layout.mReferenceIds;
|
|
return iArr == null ? new int[0] : Arrays.copyOf(iArr, iArr.length);
|
|
}
|
|
|
|
public int getVisibility(int i) {
|
|
return get(i).propertySet.visibility;
|
|
}
|
|
|
|
public int getVisibilityMode(int i) {
|
|
return get(i).propertySet.mVisibilityMode;
|
|
}
|
|
|
|
public int getWidth(int i) {
|
|
return get(i).layout.mWidth;
|
|
}
|
|
|
|
public boolean isForceId() {
|
|
return this.mForceId;
|
|
}
|
|
|
|
public void load(Context context, int i) {
|
|
XmlResourceParser xml = context.getResources().getXml(i);
|
|
try {
|
|
for (int eventType = xml.getEventType(); eventType != 1; eventType = xml.next()) {
|
|
if (eventType == 0) {
|
|
xml.getName();
|
|
} else if (eventType == 2) {
|
|
String name = xml.getName();
|
|
Constraint fillFromAttributeList = fillFromAttributeList(context, Xml.asAttributeSet(xml));
|
|
if (name.equalsIgnoreCase("Guideline")) {
|
|
fillFromAttributeList.layout.mIsGuideline = true;
|
|
}
|
|
this.mConstraints.put(Integer.valueOf(fillFromAttributeList.mViewId), fillFromAttributeList);
|
|
}
|
|
}
|
|
} catch (XmlPullParserException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e2) {
|
|
e2.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Can't fix incorrect switch cases order, some code will duplicate */
|
|
/* JADX WARNING: Code restructure failed: missing block: B:33:0x0079, code lost:
|
|
if (r0.equals("PropertySet") != false) goto L_0x0091;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:90:0x0179, code lost:
|
|
continue;
|
|
*/
|
|
public void load(Context context, XmlPullParser xmlPullParser) {
|
|
Constraint constraint;
|
|
try {
|
|
int eventType = xmlPullParser.getEventType();
|
|
Constraint constraint2 = null;
|
|
while (eventType != 1) {
|
|
if (eventType != 0) {
|
|
char c2 = 3;
|
|
if (eventType == 2) {
|
|
String name = xmlPullParser.getName();
|
|
switch (name.hashCode()) {
|
|
case -2025855158:
|
|
if (name.equals("Layout")) {
|
|
c2 = 5;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case -1984451626:
|
|
if (name.equals("Motion")) {
|
|
c2 = 6;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case -1269513683:
|
|
break;
|
|
case -1238332596:
|
|
if (name.equals("Transform")) {
|
|
c2 = 4;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case -71750448:
|
|
if (name.equals("Guideline")) {
|
|
c2 = 1;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 1331510167:
|
|
if (name.equals("Barrier")) {
|
|
c2 = 2;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 1791837707:
|
|
if (name.equals("CustomAttribute")) {
|
|
c2 = 7;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
case 1803088381:
|
|
if (name.equals("Constraint")) {
|
|
c2 = 0;
|
|
break;
|
|
}
|
|
c2 = 65535;
|
|
break;
|
|
default:
|
|
c2 = 65535;
|
|
break;
|
|
}
|
|
switch (c2) {
|
|
case 0:
|
|
constraint = fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
constraint2 = constraint;
|
|
break;
|
|
case 1:
|
|
constraint = fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
Layout layout = constraint.layout;
|
|
layout.mIsGuideline = true;
|
|
layout.mApply = true;
|
|
constraint2 = constraint;
|
|
break;
|
|
case 2:
|
|
constraint = fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
constraint.layout.mHelperType = 1;
|
|
constraint2 = constraint;
|
|
break;
|
|
case 3:
|
|
if (constraint2 != null) {
|
|
constraint2.propertySet.fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
break;
|
|
} else {
|
|
throw new RuntimeException(ERROR_MESSAGE + xmlPullParser.getLineNumber());
|
|
}
|
|
case 4:
|
|
if (constraint2 != null) {
|
|
constraint2.transform.fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
break;
|
|
} else {
|
|
throw new RuntimeException(ERROR_MESSAGE + xmlPullParser.getLineNumber());
|
|
}
|
|
case 5:
|
|
if (constraint2 != null) {
|
|
constraint2.layout.fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
break;
|
|
} else {
|
|
throw new RuntimeException(ERROR_MESSAGE + xmlPullParser.getLineNumber());
|
|
}
|
|
case 6:
|
|
if (constraint2 != null) {
|
|
constraint2.motion.fillFromAttributeList(context, Xml.asAttributeSet(xmlPullParser));
|
|
break;
|
|
} else {
|
|
throw new RuntimeException(ERROR_MESSAGE + xmlPullParser.getLineNumber());
|
|
}
|
|
case 7:
|
|
if (constraint2 != null) {
|
|
ConstraintAttribute.parse(context, xmlPullParser, constraint2.mCustomConstraints);
|
|
break;
|
|
} else {
|
|
throw new RuntimeException(ERROR_MESSAGE + xmlPullParser.getLineNumber());
|
|
}
|
|
}
|
|
} else if (eventType != 3) {
|
|
continue;
|
|
} else {
|
|
String name2 = xmlPullParser.getName();
|
|
if (!TAG.equals(name2)) {
|
|
if (name2.equalsIgnoreCase("Constraint")) {
|
|
this.mConstraints.put(Integer.valueOf(constraint2.mViewId), constraint2);
|
|
constraint2 = null;
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
xmlPullParser.getName();
|
|
}
|
|
eventType = xmlPullParser.next();
|
|
}
|
|
} catch (XmlPullParserException e) {
|
|
e.printStackTrace();
|
|
} catch (IOException e2) {
|
|
e2.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public void parseColorAttributes(Constraint constraint, String str) {
|
|
String[] split = str.split(",");
|
|
for (int i = 0; i < split.length; i++) {
|
|
String[] split2 = split[i].split("=");
|
|
if (split2.length != 2) {
|
|
a.j0(a.L(" Unable to parse "), split[i], TAG);
|
|
} else {
|
|
Constraint.access$600(constraint, split2[0], Color.parseColor(split2[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void parseFloatAttributes(Constraint constraint, String str) {
|
|
String[] split = str.split(",");
|
|
for (int i = 0; i < split.length; i++) {
|
|
String[] split2 = split[i].split("=");
|
|
if (split2.length != 2) {
|
|
a.j0(a.L(" Unable to parse "), split[i], TAG);
|
|
} else {
|
|
Constraint.access$700(constraint, split2[0], Float.parseFloat(split2[1]));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void parseIntAttributes(Constraint constraint, String str) {
|
|
String[] split = str.split(",");
|
|
for (int i = 0; i < split.length; i++) {
|
|
String[] split2 = split[i].split("=");
|
|
if (split2.length != 2) {
|
|
a.j0(a.L(" Unable to parse "), split[i], TAG);
|
|
} else {
|
|
Constraint.access$700(constraint, split2[0], (float) Integer.decode(split2[1]).intValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void parseStringAttributes(Constraint constraint, String str) {
|
|
String[] splitString = splitString(str);
|
|
for (int i = 0; i < splitString.length; i++) {
|
|
String[] split = splitString[i].split("=");
|
|
a.j0(a.L(" Unable to parse "), splitString[i], TAG);
|
|
Constraint.access$800(constraint, split[0], split[1]);
|
|
}
|
|
}
|
|
|
|
public void readFallback(ConstraintLayout constraintLayout) {
|
|
int childCount = constraintLayout.getChildCount();
|
|
for (int i = 0; i < childCount; i++) {
|
|
View childAt = constraintLayout.getChildAt(i);
|
|
ConstraintLayout.LayoutParams layoutParams = (ConstraintLayout.LayoutParams) childAt.getLayoutParams();
|
|
int id2 = childAt.getId();
|
|
if (!this.mForceId || id2 != -1) {
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(id2))) {
|
|
this.mConstraints.put(Integer.valueOf(id2), new Constraint());
|
|
}
|
|
Constraint constraint = this.mConstraints.get(Integer.valueOf(id2));
|
|
if (!constraint.layout.mApply) {
|
|
Constraint.access$000(constraint, id2, layoutParams);
|
|
if (childAt instanceof ConstraintHelper) {
|
|
constraint.layout.mReferenceIds = ((ConstraintHelper) childAt).getReferencedIds();
|
|
if (childAt instanceof Barrier) {
|
|
Barrier barrier = (Barrier) childAt;
|
|
constraint.layout.mBarrierAllowsGoneWidgets = barrier.allowsGoneWidget();
|
|
constraint.layout.mBarrierDirection = barrier.getType();
|
|
constraint.layout.mBarrierMargin = barrier.getMargin();
|
|
}
|
|
}
|
|
constraint.layout.mApply = true;
|
|
}
|
|
PropertySet propertySet = constraint.propertySet;
|
|
if (!propertySet.mApply) {
|
|
propertySet.visibility = childAt.getVisibility();
|
|
constraint.propertySet.alpha = childAt.getAlpha();
|
|
constraint.propertySet.mApply = true;
|
|
}
|
|
Transform transform = constraint.transform;
|
|
if (!transform.mApply) {
|
|
transform.mApply = true;
|
|
transform.rotation = childAt.getRotation();
|
|
constraint.transform.rotationX = childAt.getRotationX();
|
|
constraint.transform.rotationY = childAt.getRotationY();
|
|
constraint.transform.scaleX = childAt.getScaleX();
|
|
constraint.transform.scaleY = childAt.getScaleY();
|
|
float pivotX = childAt.getPivotX();
|
|
float pivotY = childAt.getPivotY();
|
|
if (!(((double) pivotX) == ShadowDrawableWrapper.COS_45 && ((double) pivotY) == ShadowDrawableWrapper.COS_45)) {
|
|
Transform transform2 = constraint.transform;
|
|
transform2.transformPivotX = pivotX;
|
|
transform2.transformPivotY = pivotY;
|
|
}
|
|
constraint.transform.translationX = childAt.getTranslationX();
|
|
constraint.transform.translationY = childAt.getTranslationY();
|
|
constraint.transform.translationZ = childAt.getTranslationZ();
|
|
Transform transform3 = constraint.transform;
|
|
if (transform3.applyElevation) {
|
|
transform3.elevation = childAt.getElevation();
|
|
}
|
|
}
|
|
} else {
|
|
throw new RuntimeException("All children of ConstraintLayout must have ids to use ConstraintSet");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void readFallback(ConstraintSet constraintSet) {
|
|
for (Integer num : constraintSet.mConstraints.keySet()) {
|
|
int intValue = num.intValue();
|
|
Constraint constraint = constraintSet.mConstraints.get(num);
|
|
if (!this.mConstraints.containsKey(Integer.valueOf(intValue))) {
|
|
this.mConstraints.put(Integer.valueOf(intValue), new Constraint());
|
|
}
|
|
Constraint constraint2 = this.mConstraints.get(Integer.valueOf(intValue));
|
|
Layout layout = constraint2.layout;
|
|
if (!layout.mApply) {
|
|
layout.copyFrom(constraint.layout);
|
|
}
|
|
PropertySet propertySet = constraint2.propertySet;
|
|
if (!propertySet.mApply) {
|
|
propertySet.copyFrom(constraint.propertySet);
|
|
}
|
|
Transform transform = constraint2.transform;
|
|
if (!transform.mApply) {
|
|
transform.copyFrom(constraint.transform);
|
|
}
|
|
Motion motion = constraint2.motion;
|
|
if (!motion.mApply) {
|
|
motion.copyFrom(constraint.motion);
|
|
}
|
|
for (String str : constraint.mCustomConstraints.keySet()) {
|
|
if (!constraint2.mCustomConstraints.containsKey(str)) {
|
|
constraint2.mCustomConstraints.put(str, constraint.mCustomConstraints.get(str));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeAttribute(String str) {
|
|
this.mSavedAttributes.remove(str);
|
|
}
|
|
|
|
public void removeFromHorizontalChain(int i) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
Layout layout = this.mConstraints.get(Integer.valueOf(i)).layout;
|
|
int i2 = layout.leftToRight;
|
|
int i3 = layout.rightToLeft;
|
|
if (i2 == -1 && i3 == -1) {
|
|
int i4 = layout.startToEnd;
|
|
int i5 = layout.endToStart;
|
|
if (!(i4 == -1 && i5 == -1)) {
|
|
if (i4 != -1 && i5 != -1) {
|
|
connect(i4, 7, i5, 6, 0);
|
|
connect(i5, 6, i2, 7, 0);
|
|
} else if (!(i2 == -1 && i5 == -1)) {
|
|
int i6 = layout.rightToRight;
|
|
if (i6 != -1) {
|
|
connect(i2, 7, i6, 7, 0);
|
|
} else {
|
|
int i7 = layout.leftToLeft;
|
|
if (i7 != -1) {
|
|
connect(i5, 6, i7, 6, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
clear(i, 6);
|
|
clear(i, 7);
|
|
return;
|
|
}
|
|
if (i2 != -1 && i3 != -1) {
|
|
connect(i2, 2, i3, 1, 0);
|
|
connect(i3, 1, i2, 2, 0);
|
|
} else if (!(i2 == -1 && i3 == -1)) {
|
|
int i8 = layout.rightToRight;
|
|
if (i8 != -1) {
|
|
connect(i2, 2, i8, 2, 0);
|
|
} else {
|
|
int i9 = layout.leftToLeft;
|
|
if (i9 != -1) {
|
|
connect(i3, 1, i9, 1, 0);
|
|
}
|
|
}
|
|
}
|
|
clear(i, 1);
|
|
clear(i, 2);
|
|
}
|
|
}
|
|
|
|
public void removeFromVerticalChain(int i) {
|
|
if (this.mConstraints.containsKey(Integer.valueOf(i))) {
|
|
Layout layout = this.mConstraints.get(Integer.valueOf(i)).layout;
|
|
int i2 = layout.topToBottom;
|
|
int i3 = layout.bottomToTop;
|
|
if (!(i2 == -1 && i3 == -1)) {
|
|
if (i2 != -1 && i3 != -1) {
|
|
connect(i2, 4, i3, 3, 0);
|
|
connect(i3, 3, i2, 4, 0);
|
|
} else if (!(i2 == -1 && i3 == -1)) {
|
|
int i4 = layout.bottomToBottom;
|
|
if (i4 != -1) {
|
|
connect(i2, 4, i4, 4, 0);
|
|
} else {
|
|
int i5 = layout.topToTop;
|
|
if (i5 != -1) {
|
|
connect(i3, 3, i5, 3, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
clear(i, 3);
|
|
clear(i, 4);
|
|
}
|
|
|
|
public void setAlpha(int i, float f) {
|
|
get(i).propertySet.alpha = f;
|
|
}
|
|
|
|
public void setApplyElevation(int i, boolean z2) {
|
|
get(i).transform.applyElevation = z2;
|
|
}
|
|
|
|
public void setBarrierType(int i, int i2) {
|
|
get(i).layout.mHelperType = i2;
|
|
}
|
|
|
|
public void setColorValue(int i, String str, int i2) {
|
|
Constraint.access$600(get(i), str, i2);
|
|
}
|
|
|
|
public void setDimensionRatio(int i, String str) {
|
|
get(i).layout.dimensionRatio = str;
|
|
}
|
|
|
|
public void setEditorAbsoluteX(int i, int i2) {
|
|
get(i).layout.editorAbsoluteX = i2;
|
|
}
|
|
|
|
public void setEditorAbsoluteY(int i, int i2) {
|
|
get(i).layout.editorAbsoluteY = i2;
|
|
}
|
|
|
|
public void setElevation(int i, float f) {
|
|
get(i).transform.elevation = f;
|
|
get(i).transform.applyElevation = true;
|
|
}
|
|
|
|
public void setFloatValue(int i, String str, float f) {
|
|
Constraint.access$700(get(i), str, f);
|
|
}
|
|
|
|
public void setForceId(boolean z2) {
|
|
this.mForceId = z2;
|
|
}
|
|
|
|
public void setGoneMargin(int i, int i2, int i3) {
|
|
Constraint constraint = get(i);
|
|
switch (i2) {
|
|
case 1:
|
|
constraint.layout.goneLeftMargin = i3;
|
|
return;
|
|
case 2:
|
|
constraint.layout.goneRightMargin = i3;
|
|
return;
|
|
case 3:
|
|
constraint.layout.goneTopMargin = i3;
|
|
return;
|
|
case 4:
|
|
constraint.layout.goneBottomMargin = i3;
|
|
return;
|
|
case 5:
|
|
throw new IllegalArgumentException("baseline does not support margins");
|
|
case 6:
|
|
constraint.layout.goneStartMargin = i3;
|
|
return;
|
|
case 7:
|
|
constraint.layout.goneEndMargin = i3;
|
|
return;
|
|
default:
|
|
throw new IllegalArgumentException("unknown constraint");
|
|
}
|
|
}
|
|
|
|
public void setGuidelineBegin(int i, int i2) {
|
|
get(i).layout.guideBegin = i2;
|
|
get(i).layout.guideEnd = -1;
|
|
get(i).layout.guidePercent = -1.0f;
|
|
}
|
|
|
|
public void setGuidelineEnd(int i, int i2) {
|
|
get(i).layout.guideEnd = i2;
|
|
get(i).layout.guideBegin = -1;
|
|
get(i).layout.guidePercent = -1.0f;
|
|
}
|
|
|
|
public void setGuidelinePercent(int i, float f) {
|
|
get(i).layout.guidePercent = f;
|
|
get(i).layout.guideEnd = -1;
|
|
get(i).layout.guideBegin = -1;
|
|
}
|
|
|
|
public void setHorizontalBias(int i, float f) {
|
|
get(i).layout.horizontalBias = f;
|
|
}
|
|
|
|
public void setHorizontalChainStyle(int i, int i2) {
|
|
get(i).layout.horizontalChainStyle = i2;
|
|
}
|
|
|
|
public void setHorizontalWeight(int i, float f) {
|
|
get(i).layout.horizontalWeight = f;
|
|
}
|
|
|
|
public void setIntValue(int i, String str, int i2) {
|
|
Constraint.access$500(get(i), str, i2);
|
|
}
|
|
|
|
public void setMargin(int i, int i2, int i3) {
|
|
Constraint constraint = get(i);
|
|
switch (i2) {
|
|
case 1:
|
|
constraint.layout.leftMargin = i3;
|
|
return;
|
|
case 2:
|
|
constraint.layout.rightMargin = i3;
|
|
return;
|
|
case 3:
|
|
constraint.layout.topMargin = i3;
|
|
return;
|
|
case 4:
|
|
constraint.layout.bottomMargin = i3;
|
|
return;
|
|
case 5:
|
|
throw new IllegalArgumentException("baseline does not support margins");
|
|
case 6:
|
|
constraint.layout.startMargin = i3;
|
|
return;
|
|
case 7:
|
|
constraint.layout.endMargin = i3;
|
|
return;
|
|
default:
|
|
throw new IllegalArgumentException("unknown constraint");
|
|
}
|
|
}
|
|
|
|
public void setReferencedIds(int i, int... iArr) {
|
|
get(i).layout.mReferenceIds = iArr;
|
|
}
|
|
|
|
public void setRotation(int i, float f) {
|
|
get(i).transform.rotation = f;
|
|
}
|
|
|
|
public void setRotationX(int i, float f) {
|
|
get(i).transform.rotationX = f;
|
|
}
|
|
|
|
public void setRotationY(int i, float f) {
|
|
get(i).transform.rotationY = f;
|
|
}
|
|
|
|
public void setScaleX(int i, float f) {
|
|
get(i).transform.scaleX = f;
|
|
}
|
|
|
|
public void setScaleY(int i, float f) {
|
|
get(i).transform.scaleY = f;
|
|
}
|
|
|
|
public void setStringValue(int i, String str, String str2) {
|
|
Constraint.access$800(get(i), str, str2);
|
|
}
|
|
|
|
public void setTransformPivot(int i, float f, float f2) {
|
|
Transform transform = get(i).transform;
|
|
transform.transformPivotY = f2;
|
|
transform.transformPivotX = f;
|
|
}
|
|
|
|
public void setTransformPivotX(int i, float f) {
|
|
get(i).transform.transformPivotX = f;
|
|
}
|
|
|
|
public void setTransformPivotY(int i, float f) {
|
|
get(i).transform.transformPivotY = f;
|
|
}
|
|
|
|
public void setTranslation(int i, float f, float f2) {
|
|
Transform transform = get(i).transform;
|
|
transform.translationX = f;
|
|
transform.translationY = f2;
|
|
}
|
|
|
|
public void setTranslationX(int i, float f) {
|
|
get(i).transform.translationX = f;
|
|
}
|
|
|
|
public void setTranslationY(int i, float f) {
|
|
get(i).transform.translationY = f;
|
|
}
|
|
|
|
public void setTranslationZ(int i, float f) {
|
|
get(i).transform.translationZ = f;
|
|
}
|
|
|
|
public void setValidateOnParse(boolean z2) {
|
|
this.mValidate = z2;
|
|
}
|
|
|
|
public void setVerticalBias(int i, float f) {
|
|
get(i).layout.verticalBias = f;
|
|
}
|
|
|
|
public void setVerticalChainStyle(int i, int i2) {
|
|
get(i).layout.verticalChainStyle = i2;
|
|
}
|
|
|
|
public void setVerticalWeight(int i, float f) {
|
|
get(i).layout.verticalWeight = f;
|
|
}
|
|
|
|
public void setVisibility(int i, int i2) {
|
|
get(i).propertySet.visibility = i2;
|
|
}
|
|
|
|
public void setVisibilityMode(int i, int i2) {
|
|
get(i).propertySet.mVisibilityMode = i2;
|
|
}
|
|
}
|