1563 lines
64 KiB
Java
1563 lines
64 KiB
Java
package androidx.vectordrawable.graphics.drawable;
|
|
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.ColorFilter;
|
|
import android.graphics.Matrix;
|
|
import android.graphics.Paint;
|
|
import android.graphics.Path;
|
|
import android.graphics.PathMeasure;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.PorterDuffColorFilter;
|
|
import android.graphics.Rect;
|
|
import android.graphics.Region;
|
|
import android.graphics.Shader;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.VectorDrawable;
|
|
import android.os.Build;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.Xml;
|
|
import androidx.annotation.ColorInt;
|
|
import androidx.annotation.DrawableRes;
|
|
import androidx.annotation.NonNull;
|
|
import androidx.annotation.Nullable;
|
|
import androidx.annotation.RequiresApi;
|
|
import androidx.annotation.RestrictTo;
|
|
import androidx.collection.ArrayMap;
|
|
import androidx.core.content.res.ComplexColorCompat;
|
|
import androidx.core.content.res.ResourcesCompat;
|
|
import androidx.core.content.res.TypedArrayUtils;
|
|
import androidx.core.graphics.PathParser;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
import c.d.b.a.a;
|
|
import java.io.IOException;
|
|
import java.util.ArrayDeque;
|
|
import java.util.ArrayList;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
public class VectorDrawableCompat extends VectorDrawableCommon {
|
|
private static final boolean DBG_VECTOR_DRAWABLE = false;
|
|
public static final PorterDuff.Mode DEFAULT_TINT_MODE = PorterDuff.Mode.SRC_IN;
|
|
private static final int LINECAP_BUTT = 0;
|
|
private static final int LINECAP_ROUND = 1;
|
|
private static final int LINECAP_SQUARE = 2;
|
|
private static final int LINEJOIN_BEVEL = 2;
|
|
private static final int LINEJOIN_MITER = 0;
|
|
private static final int LINEJOIN_ROUND = 1;
|
|
public static final String LOGTAG = "VectorDrawableCompat";
|
|
private static final int MAX_CACHED_BITMAP_SIZE = 2048;
|
|
private static final String SHAPE_CLIP_PATH = "clip-path";
|
|
private static final String SHAPE_GROUP = "group";
|
|
private static final String SHAPE_PATH = "path";
|
|
private static final String SHAPE_VECTOR = "vector";
|
|
private boolean mAllowCaching;
|
|
private Drawable.ConstantState mCachedConstantStateDelegate;
|
|
private ColorFilter mColorFilter;
|
|
private boolean mMutated;
|
|
private PorterDuffColorFilter mTintFilter;
|
|
private final Rect mTmpBounds;
|
|
private final float[] mTmpFloats;
|
|
private final Matrix mTmpMatrix;
|
|
private VectorDrawableCompatState mVectorState;
|
|
|
|
public static class VClipPath extends VPath {
|
|
public VClipPath() {
|
|
}
|
|
|
|
public VClipPath(VClipPath vClipPath) {
|
|
super(vClipPath);
|
|
}
|
|
|
|
private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser) {
|
|
String string = typedArray.getString(0);
|
|
if (string != null) {
|
|
this.mPathName = string;
|
|
}
|
|
String string2 = typedArray.getString(1);
|
|
if (string2 != null) {
|
|
this.mNodes = PathParser.createNodesFromPathData(string2);
|
|
}
|
|
this.mFillRule = TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "fillType", 2, 0);
|
|
}
|
|
|
|
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
|
|
if (TypedArrayUtils.hasAttribute(xmlPullParser, "pathData")) {
|
|
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_CLIP_PATH);
|
|
updateStateFromTypedArray(obtainAttributes, xmlPullParser);
|
|
obtainAttributes.recycle();
|
|
}
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath
|
|
public boolean isClipPath() {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static class VFullPath extends VPath {
|
|
public float mFillAlpha = 1.0f;
|
|
public ComplexColorCompat mFillColor;
|
|
public float mStrokeAlpha = 1.0f;
|
|
public ComplexColorCompat mStrokeColor;
|
|
public Paint.Cap mStrokeLineCap = Paint.Cap.BUTT;
|
|
public Paint.Join mStrokeLineJoin = Paint.Join.MITER;
|
|
public float mStrokeMiterlimit = 4.0f;
|
|
public float mStrokeWidth = 0.0f;
|
|
private int[] mThemeAttrs;
|
|
public float mTrimPathEnd = 1.0f;
|
|
public float mTrimPathOffset = 0.0f;
|
|
public float mTrimPathStart = 0.0f;
|
|
|
|
public VFullPath() {
|
|
}
|
|
|
|
public VFullPath(VFullPath vFullPath) {
|
|
super(vFullPath);
|
|
this.mThemeAttrs = vFullPath.mThemeAttrs;
|
|
this.mStrokeColor = vFullPath.mStrokeColor;
|
|
this.mStrokeWidth = vFullPath.mStrokeWidth;
|
|
this.mStrokeAlpha = vFullPath.mStrokeAlpha;
|
|
this.mFillColor = vFullPath.mFillColor;
|
|
this.mFillRule = vFullPath.mFillRule;
|
|
this.mFillAlpha = vFullPath.mFillAlpha;
|
|
this.mTrimPathStart = vFullPath.mTrimPathStart;
|
|
this.mTrimPathEnd = vFullPath.mTrimPathEnd;
|
|
this.mTrimPathOffset = vFullPath.mTrimPathOffset;
|
|
this.mStrokeLineCap = vFullPath.mStrokeLineCap;
|
|
this.mStrokeLineJoin = vFullPath.mStrokeLineJoin;
|
|
this.mStrokeMiterlimit = vFullPath.mStrokeMiterlimit;
|
|
}
|
|
|
|
private Paint.Cap getStrokeLineCap(int i, Paint.Cap cap) {
|
|
return i != 0 ? i != 1 ? i != 2 ? cap : Paint.Cap.SQUARE : Paint.Cap.ROUND : Paint.Cap.BUTT;
|
|
}
|
|
|
|
private Paint.Join getStrokeLineJoin(int i, Paint.Join join) {
|
|
return i != 0 ? i != 1 ? i != 2 ? join : Paint.Join.BEVEL : Paint.Join.ROUND : Paint.Join.MITER;
|
|
}
|
|
|
|
private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme) {
|
|
this.mThemeAttrs = null;
|
|
if (TypedArrayUtils.hasAttribute(xmlPullParser, "pathData")) {
|
|
String string = typedArray.getString(0);
|
|
if (string != null) {
|
|
this.mPathName = string;
|
|
}
|
|
String string2 = typedArray.getString(2);
|
|
if (string2 != null) {
|
|
this.mNodes = PathParser.createNodesFromPathData(string2);
|
|
}
|
|
this.mFillColor = TypedArrayUtils.getNamedComplexColor(typedArray, xmlPullParser, theme, "fillColor", 1, 0);
|
|
this.mFillAlpha = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "fillAlpha", 12, this.mFillAlpha);
|
|
this.mStrokeLineCap = getStrokeLineCap(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "strokeLineCap", 8, -1), this.mStrokeLineCap);
|
|
this.mStrokeLineJoin = getStrokeLineJoin(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "strokeLineJoin", 9, -1), this.mStrokeLineJoin);
|
|
this.mStrokeMiterlimit = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeMiterLimit", 10, this.mStrokeMiterlimit);
|
|
this.mStrokeColor = TypedArrayUtils.getNamedComplexColor(typedArray, xmlPullParser, theme, "strokeColor", 3, 0);
|
|
this.mStrokeAlpha = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeAlpha", 11, this.mStrokeAlpha);
|
|
this.mStrokeWidth = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "strokeWidth", 4, this.mStrokeWidth);
|
|
this.mTrimPathEnd = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathEnd", 6, this.mTrimPathEnd);
|
|
this.mTrimPathOffset = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathOffset", 7, this.mTrimPathOffset);
|
|
this.mTrimPathStart = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "trimPathStart", 5, this.mTrimPathStart);
|
|
this.mFillRule = TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "fillType", 13, this.mFillRule);
|
|
}
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath
|
|
public void applyTheme(Resources.Theme theme) {
|
|
if (this.mThemeAttrs == null) {
|
|
}
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VPath
|
|
public boolean canApplyTheme() {
|
|
return this.mThemeAttrs != null;
|
|
}
|
|
|
|
public float getFillAlpha() {
|
|
return this.mFillAlpha;
|
|
}
|
|
|
|
@ColorInt
|
|
public int getFillColor() {
|
|
return this.mFillColor.getColor();
|
|
}
|
|
|
|
public float getStrokeAlpha() {
|
|
return this.mStrokeAlpha;
|
|
}
|
|
|
|
@ColorInt
|
|
public int getStrokeColor() {
|
|
return this.mStrokeColor.getColor();
|
|
}
|
|
|
|
public float getStrokeWidth() {
|
|
return this.mStrokeWidth;
|
|
}
|
|
|
|
public float getTrimPathEnd() {
|
|
return this.mTrimPathEnd;
|
|
}
|
|
|
|
public float getTrimPathOffset() {
|
|
return this.mTrimPathOffset;
|
|
}
|
|
|
|
public float getTrimPathStart() {
|
|
return this.mTrimPathStart;
|
|
}
|
|
|
|
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
|
|
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_PATH);
|
|
updateStateFromTypedArray(obtainAttributes, xmlPullParser, theme);
|
|
obtainAttributes.recycle();
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject
|
|
public boolean isStateful() {
|
|
return this.mFillColor.isStateful() || this.mStrokeColor.isStateful();
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject
|
|
public boolean onStateChanged(int[] iArr) {
|
|
return this.mStrokeColor.onStateChanged(iArr) | this.mFillColor.onStateChanged(iArr);
|
|
}
|
|
|
|
public void setFillAlpha(float f) {
|
|
this.mFillAlpha = f;
|
|
}
|
|
|
|
public void setFillColor(int i) {
|
|
this.mFillColor.setColor(i);
|
|
}
|
|
|
|
public void setStrokeAlpha(float f) {
|
|
this.mStrokeAlpha = f;
|
|
}
|
|
|
|
public void setStrokeColor(int i) {
|
|
this.mStrokeColor.setColor(i);
|
|
}
|
|
|
|
public void setStrokeWidth(float f) {
|
|
this.mStrokeWidth = f;
|
|
}
|
|
|
|
public void setTrimPathEnd(float f) {
|
|
this.mTrimPathEnd = f;
|
|
}
|
|
|
|
public void setTrimPathOffset(float f) {
|
|
this.mTrimPathOffset = f;
|
|
}
|
|
|
|
public void setTrimPathStart(float f) {
|
|
this.mTrimPathStart = f;
|
|
}
|
|
}
|
|
|
|
public static class VGroup extends VObject {
|
|
public int mChangingConfigurations;
|
|
public final ArrayList<VObject> mChildren;
|
|
private String mGroupName;
|
|
public final Matrix mLocalMatrix;
|
|
private float mPivotX;
|
|
private float mPivotY;
|
|
public float mRotate;
|
|
private float mScaleX;
|
|
private float mScaleY;
|
|
public final Matrix mStackedMatrix;
|
|
private int[] mThemeAttrs;
|
|
private float mTranslateX;
|
|
private float mTranslateY;
|
|
|
|
public VGroup() {
|
|
super();
|
|
this.mStackedMatrix = new Matrix();
|
|
this.mChildren = new ArrayList<>();
|
|
this.mRotate = 0.0f;
|
|
this.mPivotX = 0.0f;
|
|
this.mPivotY = 0.0f;
|
|
this.mScaleX = 1.0f;
|
|
this.mScaleY = 1.0f;
|
|
this.mTranslateX = 0.0f;
|
|
this.mTranslateY = 0.0f;
|
|
this.mLocalMatrix = new Matrix();
|
|
this.mGroupName = null;
|
|
}
|
|
|
|
public VGroup(VGroup vGroup, ArrayMap<String, Object> arrayMap) {
|
|
super();
|
|
VPath vPath;
|
|
this.mStackedMatrix = new Matrix();
|
|
this.mChildren = new ArrayList<>();
|
|
this.mRotate = 0.0f;
|
|
this.mPivotX = 0.0f;
|
|
this.mPivotY = 0.0f;
|
|
this.mScaleX = 1.0f;
|
|
this.mScaleY = 1.0f;
|
|
this.mTranslateX = 0.0f;
|
|
this.mTranslateY = 0.0f;
|
|
Matrix matrix = new Matrix();
|
|
this.mLocalMatrix = matrix;
|
|
this.mGroupName = null;
|
|
this.mRotate = vGroup.mRotate;
|
|
this.mPivotX = vGroup.mPivotX;
|
|
this.mPivotY = vGroup.mPivotY;
|
|
this.mScaleX = vGroup.mScaleX;
|
|
this.mScaleY = vGroup.mScaleY;
|
|
this.mTranslateX = vGroup.mTranslateX;
|
|
this.mTranslateY = vGroup.mTranslateY;
|
|
this.mThemeAttrs = vGroup.mThemeAttrs;
|
|
String str = vGroup.mGroupName;
|
|
this.mGroupName = str;
|
|
this.mChangingConfigurations = vGroup.mChangingConfigurations;
|
|
if (str != null) {
|
|
arrayMap.put(str, this);
|
|
}
|
|
matrix.set(vGroup.mLocalMatrix);
|
|
ArrayList<VObject> arrayList = vGroup.mChildren;
|
|
for (int i = 0; i < arrayList.size(); i++) {
|
|
VObject vObject = arrayList.get(i);
|
|
if (vObject instanceof VGroup) {
|
|
this.mChildren.add(new VGroup((VGroup) vObject, arrayMap));
|
|
} else {
|
|
if (vObject instanceof VFullPath) {
|
|
vPath = new VFullPath((VFullPath) vObject);
|
|
} else if (vObject instanceof VClipPath) {
|
|
vPath = new VClipPath((VClipPath) vObject);
|
|
} else {
|
|
throw new IllegalStateException("Unknown object in the tree!");
|
|
}
|
|
this.mChildren.add(vPath);
|
|
String str2 = vPath.mPathName;
|
|
if (str2 != null) {
|
|
arrayMap.put(str2, vPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateLocalMatrix() {
|
|
this.mLocalMatrix.reset();
|
|
this.mLocalMatrix.postTranslate(-this.mPivotX, -this.mPivotY);
|
|
this.mLocalMatrix.postScale(this.mScaleX, this.mScaleY);
|
|
this.mLocalMatrix.postRotate(this.mRotate, 0.0f, 0.0f);
|
|
this.mLocalMatrix.postTranslate(this.mTranslateX + this.mPivotX, this.mTranslateY + this.mPivotY);
|
|
}
|
|
|
|
private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser) {
|
|
this.mThemeAttrs = null;
|
|
this.mRotate = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "rotation", 5, this.mRotate);
|
|
this.mPivotX = typedArray.getFloat(1, this.mPivotX);
|
|
this.mPivotY = typedArray.getFloat(2, this.mPivotY);
|
|
this.mScaleX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "scaleX", 3, this.mScaleX);
|
|
this.mScaleY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "scaleY", 4, this.mScaleY);
|
|
this.mTranslateX = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "translateX", 6, this.mTranslateX);
|
|
this.mTranslateY = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "translateY", 7, this.mTranslateY);
|
|
String string = typedArray.getString(0);
|
|
if (string != null) {
|
|
this.mGroupName = string;
|
|
}
|
|
updateLocalMatrix();
|
|
}
|
|
|
|
public String getGroupName() {
|
|
return this.mGroupName;
|
|
}
|
|
|
|
public Matrix getLocalMatrix() {
|
|
return this.mLocalMatrix;
|
|
}
|
|
|
|
public float getPivotX() {
|
|
return this.mPivotX;
|
|
}
|
|
|
|
public float getPivotY() {
|
|
return this.mPivotY;
|
|
}
|
|
|
|
public float getRotation() {
|
|
return this.mRotate;
|
|
}
|
|
|
|
public float getScaleX() {
|
|
return this.mScaleX;
|
|
}
|
|
|
|
public float getScaleY() {
|
|
return this.mScaleY;
|
|
}
|
|
|
|
public float getTranslateX() {
|
|
return this.mTranslateX;
|
|
}
|
|
|
|
public float getTranslateY() {
|
|
return this.mTranslateY;
|
|
}
|
|
|
|
public void inflate(Resources resources, AttributeSet attributeSet, Resources.Theme theme, XmlPullParser xmlPullParser) {
|
|
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_GROUP);
|
|
updateStateFromTypedArray(obtainAttributes, xmlPullParser);
|
|
obtainAttributes.recycle();
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject
|
|
public boolean isStateful() {
|
|
for (int i = 0; i < this.mChildren.size(); i++) {
|
|
if (this.mChildren.get(i).isStateful()) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCompat.VObject
|
|
public boolean onStateChanged(int[] iArr) {
|
|
boolean z2 = false;
|
|
for (int i = 0; i < this.mChildren.size(); i++) {
|
|
z2 |= this.mChildren.get(i).onStateChanged(iArr);
|
|
}
|
|
return z2;
|
|
}
|
|
|
|
public void setPivotX(float f) {
|
|
if (f != this.mPivotX) {
|
|
this.mPivotX = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setPivotY(float f) {
|
|
if (f != this.mPivotY) {
|
|
this.mPivotY = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setRotation(float f) {
|
|
if (f != this.mRotate) {
|
|
this.mRotate = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setScaleX(float f) {
|
|
if (f != this.mScaleX) {
|
|
this.mScaleX = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setScaleY(float f) {
|
|
if (f != this.mScaleY) {
|
|
this.mScaleY = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setTranslateX(float f) {
|
|
if (f != this.mTranslateX) {
|
|
this.mTranslateX = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
|
|
public void setTranslateY(float f) {
|
|
if (f != this.mTranslateY) {
|
|
this.mTranslateY = f;
|
|
updateLocalMatrix();
|
|
}
|
|
}
|
|
}
|
|
|
|
public static abstract class VObject {
|
|
private VObject() {
|
|
}
|
|
|
|
public boolean isStateful() {
|
|
return false;
|
|
}
|
|
|
|
public boolean onStateChanged(int[] iArr) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static abstract class VPath extends VObject {
|
|
public static final int FILL_TYPE_WINDING = 0;
|
|
public int mChangingConfigurations;
|
|
public int mFillRule = 0;
|
|
public PathParser.PathDataNode[] mNodes = null;
|
|
public String mPathName;
|
|
|
|
public VPath() {
|
|
super();
|
|
}
|
|
|
|
public VPath(VPath vPath) {
|
|
super();
|
|
this.mPathName = vPath.mPathName;
|
|
this.mChangingConfigurations = vPath.mChangingConfigurations;
|
|
this.mNodes = PathParser.deepCopyNodes(vPath.mNodes);
|
|
}
|
|
|
|
public void applyTheme(Resources.Theme theme) {
|
|
}
|
|
|
|
public boolean canApplyTheme() {
|
|
return false;
|
|
}
|
|
|
|
public PathParser.PathDataNode[] getPathData() {
|
|
return this.mNodes;
|
|
}
|
|
|
|
public String getPathName() {
|
|
return this.mPathName;
|
|
}
|
|
|
|
public boolean isClipPath() {
|
|
return false;
|
|
}
|
|
|
|
public String nodesToString(PathParser.PathDataNode[] pathDataNodeArr) {
|
|
float[] fArr;
|
|
String str = " ";
|
|
for (int i = 0; i < pathDataNodeArr.length; i++) {
|
|
StringBuilder L = a.L(str);
|
|
L.append(pathDataNodeArr[i].mType);
|
|
L.append(":");
|
|
str = L.toString();
|
|
for (float f : pathDataNodeArr[i].mParams) {
|
|
StringBuilder L2 = a.L(str);
|
|
L2.append(f);
|
|
L2.append(",");
|
|
str = L2.toString();
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
public void printVPath(int i) {
|
|
String str = "";
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
str = a.t(str, " ");
|
|
}
|
|
StringBuilder P = a.P(str, "current path is :");
|
|
P.append(this.mPathName);
|
|
P.append(" pathData is ");
|
|
P.append(nodesToString(this.mNodes));
|
|
Log.v("VectorDrawableCompat", P.toString());
|
|
}
|
|
|
|
public void setPathData(PathParser.PathDataNode[] pathDataNodeArr) {
|
|
if (!PathParser.canMorph(this.mNodes, pathDataNodeArr)) {
|
|
this.mNodes = PathParser.deepCopyNodes(pathDataNodeArr);
|
|
} else {
|
|
PathParser.updateNodes(this.mNodes, pathDataNodeArr);
|
|
}
|
|
}
|
|
|
|
public void toPath(Path path) {
|
|
path.reset();
|
|
PathParser.PathDataNode[] pathDataNodeArr = this.mNodes;
|
|
if (pathDataNodeArr != null) {
|
|
PathParser.PathDataNode.nodesToPath(pathDataNodeArr, path);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class VPathRenderer {
|
|
private static final Matrix IDENTITY_MATRIX = new Matrix();
|
|
public float mBaseHeight;
|
|
public float mBaseWidth;
|
|
private int mChangingConfigurations;
|
|
public Paint mFillPaint;
|
|
private final Matrix mFinalPathMatrix;
|
|
public Boolean mIsStateful;
|
|
private final Path mPath;
|
|
private PathMeasure mPathMeasure;
|
|
private final Path mRenderPath;
|
|
public int mRootAlpha;
|
|
public final VGroup mRootGroup;
|
|
public String mRootName;
|
|
public Paint mStrokePaint;
|
|
public final ArrayMap<String, Object> mVGTargetsMap;
|
|
public float mViewportHeight;
|
|
public float mViewportWidth;
|
|
|
|
public VPathRenderer() {
|
|
this.mFinalPathMatrix = new Matrix();
|
|
this.mBaseWidth = 0.0f;
|
|
this.mBaseHeight = 0.0f;
|
|
this.mViewportWidth = 0.0f;
|
|
this.mViewportHeight = 0.0f;
|
|
this.mRootAlpha = 255;
|
|
this.mRootName = null;
|
|
this.mIsStateful = null;
|
|
this.mVGTargetsMap = new ArrayMap<>();
|
|
this.mRootGroup = new VGroup();
|
|
this.mPath = new Path();
|
|
this.mRenderPath = new Path();
|
|
}
|
|
|
|
public VPathRenderer(VPathRenderer vPathRenderer) {
|
|
this.mFinalPathMatrix = new Matrix();
|
|
this.mBaseWidth = 0.0f;
|
|
this.mBaseHeight = 0.0f;
|
|
this.mViewportWidth = 0.0f;
|
|
this.mViewportHeight = 0.0f;
|
|
this.mRootAlpha = 255;
|
|
this.mRootName = null;
|
|
this.mIsStateful = null;
|
|
ArrayMap<String, Object> arrayMap = new ArrayMap<>();
|
|
this.mVGTargetsMap = arrayMap;
|
|
this.mRootGroup = new VGroup(vPathRenderer.mRootGroup, arrayMap);
|
|
this.mPath = new Path(vPathRenderer.mPath);
|
|
this.mRenderPath = new Path(vPathRenderer.mRenderPath);
|
|
this.mBaseWidth = vPathRenderer.mBaseWidth;
|
|
this.mBaseHeight = vPathRenderer.mBaseHeight;
|
|
this.mViewportWidth = vPathRenderer.mViewportWidth;
|
|
this.mViewportHeight = vPathRenderer.mViewportHeight;
|
|
this.mChangingConfigurations = vPathRenderer.mChangingConfigurations;
|
|
this.mRootAlpha = vPathRenderer.mRootAlpha;
|
|
this.mRootName = vPathRenderer.mRootName;
|
|
String str = vPathRenderer.mRootName;
|
|
if (str != null) {
|
|
arrayMap.put(str, this);
|
|
}
|
|
this.mIsStateful = vPathRenderer.mIsStateful;
|
|
}
|
|
|
|
private static float cross(float f, float f2, float f3, float f4) {
|
|
return (f * f4) - (f2 * f3);
|
|
}
|
|
|
|
private void drawGroupTree(VGroup vGroup, Matrix matrix, Canvas canvas, int i, int i2, ColorFilter colorFilter) {
|
|
vGroup.mStackedMatrix.set(matrix);
|
|
vGroup.mStackedMatrix.preConcat(vGroup.mLocalMatrix);
|
|
canvas.save();
|
|
for (int i3 = 0; i3 < vGroup.mChildren.size(); i3++) {
|
|
VObject vObject = vGroup.mChildren.get(i3);
|
|
if (vObject instanceof VGroup) {
|
|
drawGroupTree((VGroup) vObject, vGroup.mStackedMatrix, canvas, i, i2, colorFilter);
|
|
} else if (vObject instanceof VPath) {
|
|
drawPath(vGroup, (VPath) vObject, canvas, i, i2, colorFilter);
|
|
}
|
|
}
|
|
canvas.restore();
|
|
}
|
|
|
|
private void drawPath(VGroup vGroup, VPath vPath, Canvas canvas, int i, int i2, ColorFilter colorFilter) {
|
|
float f = ((float) i) / this.mViewportWidth;
|
|
float f2 = ((float) i2) / this.mViewportHeight;
|
|
float min = Math.min(f, f2);
|
|
Matrix matrix = vGroup.mStackedMatrix;
|
|
this.mFinalPathMatrix.set(matrix);
|
|
this.mFinalPathMatrix.postScale(f, f2);
|
|
float matrixScale = getMatrixScale(matrix);
|
|
if (matrixScale != 0.0f) {
|
|
vPath.toPath(this.mPath);
|
|
Path path = this.mPath;
|
|
this.mRenderPath.reset();
|
|
if (vPath.isClipPath()) {
|
|
this.mRenderPath.setFillType(vPath.mFillRule == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD);
|
|
this.mRenderPath.addPath(path, this.mFinalPathMatrix);
|
|
canvas.clipPath(this.mRenderPath);
|
|
return;
|
|
}
|
|
VFullPath vFullPath = (VFullPath) vPath;
|
|
float f3 = vFullPath.mTrimPathStart;
|
|
if (!(f3 == 0.0f && vFullPath.mTrimPathEnd == 1.0f)) {
|
|
float f4 = vFullPath.mTrimPathOffset;
|
|
float f5 = (f3 + f4) % 1.0f;
|
|
float f6 = (vFullPath.mTrimPathEnd + f4) % 1.0f;
|
|
if (this.mPathMeasure == null) {
|
|
this.mPathMeasure = new PathMeasure();
|
|
}
|
|
this.mPathMeasure.setPath(this.mPath, false);
|
|
float length = this.mPathMeasure.getLength();
|
|
float f7 = f5 * length;
|
|
float f8 = f6 * length;
|
|
path.reset();
|
|
if (f7 > f8) {
|
|
this.mPathMeasure.getSegment(f7, length, path, true);
|
|
this.mPathMeasure.getSegment(0.0f, f8, path, true);
|
|
} else {
|
|
this.mPathMeasure.getSegment(f7, f8, path, true);
|
|
}
|
|
path.rLineTo(0.0f, 0.0f);
|
|
}
|
|
this.mRenderPath.addPath(path, this.mFinalPathMatrix);
|
|
if (vFullPath.mFillColor.willDraw()) {
|
|
ComplexColorCompat complexColorCompat = vFullPath.mFillColor;
|
|
if (this.mFillPaint == null) {
|
|
Paint paint = new Paint(1);
|
|
this.mFillPaint = paint;
|
|
paint.setStyle(Paint.Style.FILL);
|
|
}
|
|
Paint paint2 = this.mFillPaint;
|
|
if (complexColorCompat.isGradient()) {
|
|
Shader shader = complexColorCompat.getShader();
|
|
shader.setLocalMatrix(this.mFinalPathMatrix);
|
|
paint2.setShader(shader);
|
|
paint2.setAlpha(Math.round(vFullPath.mFillAlpha * 255.0f));
|
|
} else {
|
|
paint2.setShader(null);
|
|
paint2.setAlpha(255);
|
|
paint2.setColor(VectorDrawableCompat.applyAlpha(complexColorCompat.getColor(), vFullPath.mFillAlpha));
|
|
}
|
|
paint2.setColorFilter(colorFilter);
|
|
this.mRenderPath.setFillType(vFullPath.mFillRule == 0 ? Path.FillType.WINDING : Path.FillType.EVEN_ODD);
|
|
canvas.drawPath(this.mRenderPath, paint2);
|
|
}
|
|
if (vFullPath.mStrokeColor.willDraw()) {
|
|
ComplexColorCompat complexColorCompat2 = vFullPath.mStrokeColor;
|
|
if (this.mStrokePaint == null) {
|
|
Paint paint3 = new Paint(1);
|
|
this.mStrokePaint = paint3;
|
|
paint3.setStyle(Paint.Style.STROKE);
|
|
}
|
|
Paint paint4 = this.mStrokePaint;
|
|
Paint.Join join = vFullPath.mStrokeLineJoin;
|
|
if (join != null) {
|
|
paint4.setStrokeJoin(join);
|
|
}
|
|
Paint.Cap cap = vFullPath.mStrokeLineCap;
|
|
if (cap != null) {
|
|
paint4.setStrokeCap(cap);
|
|
}
|
|
paint4.setStrokeMiter(vFullPath.mStrokeMiterlimit);
|
|
if (complexColorCompat2.isGradient()) {
|
|
Shader shader2 = complexColorCompat2.getShader();
|
|
shader2.setLocalMatrix(this.mFinalPathMatrix);
|
|
paint4.setShader(shader2);
|
|
paint4.setAlpha(Math.round(vFullPath.mStrokeAlpha * 255.0f));
|
|
} else {
|
|
paint4.setShader(null);
|
|
paint4.setAlpha(255);
|
|
paint4.setColor(VectorDrawableCompat.applyAlpha(complexColorCompat2.getColor(), vFullPath.mStrokeAlpha));
|
|
}
|
|
paint4.setColorFilter(colorFilter);
|
|
paint4.setStrokeWidth(vFullPath.mStrokeWidth * min * matrixScale);
|
|
canvas.drawPath(this.mRenderPath, paint4);
|
|
}
|
|
}
|
|
}
|
|
|
|
private float getMatrixScale(Matrix matrix) {
|
|
float[] fArr = {0.0f, 1.0f, 1.0f, 0.0f};
|
|
matrix.mapVectors(fArr);
|
|
float cross = cross(fArr[0], fArr[1], fArr[2], fArr[3]);
|
|
float max = Math.max((float) Math.hypot((double) fArr[0], (double) fArr[1]), (float) Math.hypot((double) fArr[2], (double) fArr[3]));
|
|
if (max > 0.0f) {
|
|
return Math.abs(cross) / max;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
public void draw(Canvas canvas, int i, int i2, ColorFilter colorFilter) {
|
|
drawGroupTree(this.mRootGroup, IDENTITY_MATRIX, canvas, i, i2, colorFilter);
|
|
}
|
|
|
|
public float getAlpha() {
|
|
return ((float) getRootAlpha()) / 255.0f;
|
|
}
|
|
|
|
public int getRootAlpha() {
|
|
return this.mRootAlpha;
|
|
}
|
|
|
|
public boolean isStateful() {
|
|
if (this.mIsStateful == null) {
|
|
this.mIsStateful = Boolean.valueOf(this.mRootGroup.isStateful());
|
|
}
|
|
return this.mIsStateful.booleanValue();
|
|
}
|
|
|
|
public boolean onStateChanged(int[] iArr) {
|
|
return this.mRootGroup.onStateChanged(iArr);
|
|
}
|
|
|
|
public void setAlpha(float f) {
|
|
setRootAlpha((int) (f * 255.0f));
|
|
}
|
|
|
|
public void setRootAlpha(int i) {
|
|
this.mRootAlpha = i;
|
|
}
|
|
}
|
|
|
|
public static class VectorDrawableCompatState extends Drawable.ConstantState {
|
|
public boolean mAutoMirrored;
|
|
public boolean mCacheDirty;
|
|
public boolean mCachedAutoMirrored;
|
|
public Bitmap mCachedBitmap;
|
|
public int mCachedRootAlpha;
|
|
public int[] mCachedThemeAttrs;
|
|
public ColorStateList mCachedTint;
|
|
public PorterDuff.Mode mCachedTintMode;
|
|
public int mChangingConfigurations;
|
|
public Paint mTempPaint;
|
|
public ColorStateList mTint;
|
|
public PorterDuff.Mode mTintMode;
|
|
public VPathRenderer mVPathRenderer;
|
|
|
|
public VectorDrawableCompatState() {
|
|
this.mTint = null;
|
|
this.mTintMode = VectorDrawableCompat.DEFAULT_TINT_MODE;
|
|
this.mVPathRenderer = new VPathRenderer();
|
|
}
|
|
|
|
public VectorDrawableCompatState(VectorDrawableCompatState vectorDrawableCompatState) {
|
|
this.mTint = null;
|
|
this.mTintMode = VectorDrawableCompat.DEFAULT_TINT_MODE;
|
|
if (vectorDrawableCompatState != null) {
|
|
this.mChangingConfigurations = vectorDrawableCompatState.mChangingConfigurations;
|
|
VPathRenderer vPathRenderer = new VPathRenderer(vectorDrawableCompatState.mVPathRenderer);
|
|
this.mVPathRenderer = vPathRenderer;
|
|
if (vectorDrawableCompatState.mVPathRenderer.mFillPaint != null) {
|
|
vPathRenderer.mFillPaint = new Paint(vectorDrawableCompatState.mVPathRenderer.mFillPaint);
|
|
}
|
|
if (vectorDrawableCompatState.mVPathRenderer.mStrokePaint != null) {
|
|
this.mVPathRenderer.mStrokePaint = new Paint(vectorDrawableCompatState.mVPathRenderer.mStrokePaint);
|
|
}
|
|
this.mTint = vectorDrawableCompatState.mTint;
|
|
this.mTintMode = vectorDrawableCompatState.mTintMode;
|
|
this.mAutoMirrored = vectorDrawableCompatState.mAutoMirrored;
|
|
}
|
|
}
|
|
|
|
public boolean canReuseBitmap(int i, int i2) {
|
|
return i == this.mCachedBitmap.getWidth() && i2 == this.mCachedBitmap.getHeight();
|
|
}
|
|
|
|
public boolean canReuseCache() {
|
|
return !this.mCacheDirty && this.mCachedTint == this.mTint && this.mCachedTintMode == this.mTintMode && this.mCachedAutoMirrored == this.mAutoMirrored && this.mCachedRootAlpha == this.mVPathRenderer.getRootAlpha();
|
|
}
|
|
|
|
public void createCachedBitmapIfNeeded(int i, int i2) {
|
|
if (this.mCachedBitmap == null || !canReuseBitmap(i, i2)) {
|
|
this.mCachedBitmap = Bitmap.createBitmap(i, i2, Bitmap.Config.ARGB_8888);
|
|
this.mCacheDirty = true;
|
|
}
|
|
}
|
|
|
|
public void drawCachedBitmapWithRootAlpha(Canvas canvas, ColorFilter colorFilter, Rect rect) {
|
|
canvas.drawBitmap(this.mCachedBitmap, (Rect) null, rect, getPaint(colorFilter));
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public int getChangingConfigurations() {
|
|
return this.mChangingConfigurations;
|
|
}
|
|
|
|
public Paint getPaint(ColorFilter colorFilter) {
|
|
if (!hasTranslucentRoot() && colorFilter == null) {
|
|
return null;
|
|
}
|
|
if (this.mTempPaint == null) {
|
|
Paint paint = new Paint();
|
|
this.mTempPaint = paint;
|
|
paint.setFilterBitmap(true);
|
|
}
|
|
this.mTempPaint.setAlpha(this.mVPathRenderer.getRootAlpha());
|
|
this.mTempPaint.setColorFilter(colorFilter);
|
|
return this.mTempPaint;
|
|
}
|
|
|
|
public boolean hasTranslucentRoot() {
|
|
return this.mVPathRenderer.getRootAlpha() < 255;
|
|
}
|
|
|
|
public boolean isStateful() {
|
|
return this.mVPathRenderer.isStateful();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
@NonNull
|
|
public Drawable newDrawable() {
|
|
return new VectorDrawableCompat(this);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
@NonNull
|
|
public Drawable newDrawable(Resources resources) {
|
|
return new VectorDrawableCompat(this);
|
|
}
|
|
|
|
public boolean onStateChanged(int[] iArr) {
|
|
boolean onStateChanged = this.mVPathRenderer.onStateChanged(iArr);
|
|
this.mCacheDirty |= onStateChanged;
|
|
return onStateChanged;
|
|
}
|
|
|
|
public void updateCacheStates() {
|
|
this.mCachedTint = this.mTint;
|
|
this.mCachedTintMode = this.mTintMode;
|
|
this.mCachedRootAlpha = this.mVPathRenderer.getRootAlpha();
|
|
this.mCachedAutoMirrored = this.mAutoMirrored;
|
|
this.mCacheDirty = false;
|
|
}
|
|
|
|
public void updateCachedBitmap(int i, int i2) {
|
|
this.mCachedBitmap.eraseColor(0);
|
|
this.mVPathRenderer.draw(new Canvas(this.mCachedBitmap), i, i2, null);
|
|
}
|
|
}
|
|
|
|
@RequiresApi(24)
|
|
public static class VectorDrawableDelegateState extends Drawable.ConstantState {
|
|
private final Drawable.ConstantState mDelegateState;
|
|
|
|
public VectorDrawableDelegateState(Drawable.ConstantState constantState) {
|
|
this.mDelegateState = constantState;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public boolean canApplyTheme() {
|
|
return this.mDelegateState.canApplyTheme();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public int getChangingConfigurations() {
|
|
return this.mDelegateState.getChangingConfigurations();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public Drawable newDrawable() {
|
|
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
|
|
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable();
|
|
return vectorDrawableCompat;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public Drawable newDrawable(Resources resources) {
|
|
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
|
|
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources);
|
|
return vectorDrawableCompat;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable.ConstantState
|
|
public Drawable newDrawable(Resources resources, Resources.Theme theme) {
|
|
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
|
|
vectorDrawableCompat.mDelegateDrawable = (VectorDrawable) this.mDelegateState.newDrawable(resources, theme);
|
|
return vectorDrawableCompat;
|
|
}
|
|
}
|
|
|
|
public VectorDrawableCompat() {
|
|
this.mAllowCaching = true;
|
|
this.mTmpFloats = new float[9];
|
|
this.mTmpMatrix = new Matrix();
|
|
this.mTmpBounds = new Rect();
|
|
this.mVectorState = new VectorDrawableCompatState();
|
|
}
|
|
|
|
public VectorDrawableCompat(@NonNull VectorDrawableCompatState vectorDrawableCompatState) {
|
|
this.mAllowCaching = true;
|
|
this.mTmpFloats = new float[9];
|
|
this.mTmpMatrix = new Matrix();
|
|
this.mTmpBounds = new Rect();
|
|
this.mVectorState = vectorDrawableCompatState;
|
|
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode);
|
|
}
|
|
|
|
public static int applyAlpha(int i, float f) {
|
|
return (i & 16777215) | (((int) (((float) Color.alpha(i)) * f)) << 24);
|
|
}
|
|
|
|
@Nullable
|
|
public static VectorDrawableCompat create(@NonNull Resources resources, @DrawableRes int i, @Nullable Resources.Theme theme) {
|
|
XmlResourceParser xml;
|
|
int next;
|
|
if (Build.VERSION.SDK_INT >= 24) {
|
|
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
|
|
vectorDrawableCompat.mDelegateDrawable = ResourcesCompat.getDrawable(resources, i, theme);
|
|
vectorDrawableCompat.mCachedConstantStateDelegate = new VectorDrawableDelegateState(vectorDrawableCompat.mDelegateDrawable.getConstantState());
|
|
return vectorDrawableCompat;
|
|
}
|
|
try {
|
|
xml = resources.getXml(i);
|
|
AttributeSet asAttributeSet = Xml.asAttributeSet(xml);
|
|
if (next == 2) {
|
|
return createFromXmlInner(resources, (XmlPullParser) xml, asAttributeSet, theme);
|
|
}
|
|
throw new XmlPullParserException("No start tag found");
|
|
} catch (XmlPullParserException e) {
|
|
Log.e("VectorDrawableCompat", "parser error", e);
|
|
return null;
|
|
} catch (IOException e2) {
|
|
Log.e("VectorDrawableCompat", "parser error", e2);
|
|
return null;
|
|
}
|
|
while (true) {
|
|
next = xml.next();
|
|
if (next == 2 || next == 1) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static VectorDrawableCompat createFromXmlInner(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
|
|
VectorDrawableCompat vectorDrawableCompat = new VectorDrawableCompat();
|
|
vectorDrawableCompat.inflate(resources, xmlPullParser, attributeSet, theme);
|
|
return vectorDrawableCompat;
|
|
}
|
|
|
|
private void inflateInternal(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
VPathRenderer vPathRenderer = vectorDrawableCompatState.mVPathRenderer;
|
|
ArrayDeque arrayDeque = new ArrayDeque();
|
|
arrayDeque.push(vPathRenderer.mRootGroup);
|
|
int eventType = xmlPullParser.getEventType();
|
|
int depth = xmlPullParser.getDepth() + 1;
|
|
boolean z2 = true;
|
|
while (eventType != 1 && (xmlPullParser.getDepth() >= depth || eventType != 3)) {
|
|
if (eventType == 2) {
|
|
String name = xmlPullParser.getName();
|
|
VGroup vGroup = (VGroup) arrayDeque.peek();
|
|
if ("path".equals(name)) {
|
|
VFullPath vFullPath = new VFullPath();
|
|
vFullPath.inflate(resources, attributeSet, theme, xmlPullParser);
|
|
vGroup.mChildren.add(vFullPath);
|
|
if (vFullPath.getPathName() != null) {
|
|
vPathRenderer.mVGTargetsMap.put(vFullPath.getPathName(), vFullPath);
|
|
}
|
|
z2 = false;
|
|
vectorDrawableCompatState.mChangingConfigurations = vFullPath.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations;
|
|
} else if ("clip-path".equals(name)) {
|
|
VClipPath vClipPath = new VClipPath();
|
|
vClipPath.inflate(resources, attributeSet, theme, xmlPullParser);
|
|
vGroup.mChildren.add(vClipPath);
|
|
if (vClipPath.getPathName() != null) {
|
|
vPathRenderer.mVGTargetsMap.put(vClipPath.getPathName(), vClipPath);
|
|
}
|
|
vectorDrawableCompatState.mChangingConfigurations = vClipPath.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations;
|
|
} else if ("group".equals(name)) {
|
|
VGroup vGroup2 = new VGroup();
|
|
vGroup2.inflate(resources, attributeSet, theme, xmlPullParser);
|
|
vGroup.mChildren.add(vGroup2);
|
|
arrayDeque.push(vGroup2);
|
|
if (vGroup2.getGroupName() != null) {
|
|
vPathRenderer.mVGTargetsMap.put(vGroup2.getGroupName(), vGroup2);
|
|
}
|
|
vectorDrawableCompatState.mChangingConfigurations = vGroup2.mChangingConfigurations | vectorDrawableCompatState.mChangingConfigurations;
|
|
}
|
|
} else if (eventType == 3 && "group".equals(xmlPullParser.getName())) {
|
|
arrayDeque.pop();
|
|
}
|
|
eventType = xmlPullParser.next();
|
|
}
|
|
if (z2) {
|
|
throw new XmlPullParserException("no path defined");
|
|
}
|
|
}
|
|
|
|
private boolean needMirroring() {
|
|
return isAutoMirrored() && DrawableCompat.getLayoutDirection(this) == 1;
|
|
}
|
|
|
|
private static PorterDuff.Mode parseTintModeCompat(int i, PorterDuff.Mode mode) {
|
|
if (i == 3) {
|
|
return PorterDuff.Mode.SRC_OVER;
|
|
}
|
|
if (i == 5) {
|
|
return PorterDuff.Mode.SRC_IN;
|
|
}
|
|
if (i == 9) {
|
|
return PorterDuff.Mode.SRC_ATOP;
|
|
}
|
|
switch (i) {
|
|
case 14:
|
|
return PorterDuff.Mode.MULTIPLY;
|
|
case 15:
|
|
return PorterDuff.Mode.SCREEN;
|
|
case 16:
|
|
return PorterDuff.Mode.ADD;
|
|
default:
|
|
return mode;
|
|
}
|
|
}
|
|
|
|
private void printGroupTree(VGroup vGroup, int i) {
|
|
String str = "";
|
|
for (int i2 = 0; i2 < i; i2++) {
|
|
str = a.t(str, " ");
|
|
}
|
|
StringBuilder P = a.P(str, "current group is :");
|
|
P.append(vGroup.getGroupName());
|
|
P.append(" rotation is ");
|
|
P.append(vGroup.mRotate);
|
|
Log.v("VectorDrawableCompat", P.toString());
|
|
Log.v("VectorDrawableCompat", str + "matrix is :" + vGroup.getLocalMatrix().toString());
|
|
for (int i3 = 0; i3 < vGroup.mChildren.size(); i3++) {
|
|
VObject vObject = vGroup.mChildren.get(i3);
|
|
if (vObject instanceof VGroup) {
|
|
printGroupTree((VGroup) vObject, i + 1);
|
|
} else {
|
|
((VPath) vObject).printVPath(i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateStateFromTypedArray(TypedArray typedArray, XmlPullParser xmlPullParser, Resources.Theme theme) throws XmlPullParserException {
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
VPathRenderer vPathRenderer = vectorDrawableCompatState.mVPathRenderer;
|
|
vectorDrawableCompatState.mTintMode = parseTintModeCompat(TypedArrayUtils.getNamedInt(typedArray, xmlPullParser, "tintMode", 6, -1), PorterDuff.Mode.SRC_IN);
|
|
ColorStateList namedColorStateList = TypedArrayUtils.getNamedColorStateList(typedArray, xmlPullParser, theme, "tint", 1);
|
|
if (namedColorStateList != null) {
|
|
vectorDrawableCompatState.mTint = namedColorStateList;
|
|
}
|
|
vectorDrawableCompatState.mAutoMirrored = TypedArrayUtils.getNamedBoolean(typedArray, xmlPullParser, "autoMirrored", 5, vectorDrawableCompatState.mAutoMirrored);
|
|
vPathRenderer.mViewportWidth = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "viewportWidth", 7, vPathRenderer.mViewportWidth);
|
|
float namedFloat = TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "viewportHeight", 8, vPathRenderer.mViewportHeight);
|
|
vPathRenderer.mViewportHeight = namedFloat;
|
|
if (vPathRenderer.mViewportWidth <= 0.0f) {
|
|
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires viewportWidth > 0");
|
|
} else if (namedFloat > 0.0f) {
|
|
vPathRenderer.mBaseWidth = typedArray.getDimension(3, vPathRenderer.mBaseWidth);
|
|
float dimension = typedArray.getDimension(2, vPathRenderer.mBaseHeight);
|
|
vPathRenderer.mBaseHeight = dimension;
|
|
if (vPathRenderer.mBaseWidth <= 0.0f) {
|
|
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires width > 0");
|
|
} else if (dimension > 0.0f) {
|
|
vPathRenderer.setAlpha(TypedArrayUtils.getNamedFloat(typedArray, xmlPullParser, "alpha", 4, vPathRenderer.getAlpha()));
|
|
String string = typedArray.getString(0);
|
|
if (string != null) {
|
|
vPathRenderer.mRootName = string;
|
|
vPathRenderer.mVGTargetsMap.put(string, vPathRenderer);
|
|
}
|
|
} else {
|
|
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires height > 0");
|
|
}
|
|
} else {
|
|
throw new XmlPullParserException(typedArray.getPositionDescription() + "<vector> tag requires viewportHeight > 0");
|
|
}
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void applyTheme(Resources.Theme theme) {
|
|
super.applyTheme(theme);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean canApplyTheme() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable == null) {
|
|
return false;
|
|
}
|
|
DrawableCompat.canApplyTheme(drawable);
|
|
return false;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void clearColorFilter() {
|
|
super.clearColorFilter();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void draw(Canvas canvas) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.draw(canvas);
|
|
return;
|
|
}
|
|
copyBounds(this.mTmpBounds);
|
|
if (this.mTmpBounds.width() > 0 && this.mTmpBounds.height() > 0) {
|
|
ColorFilter colorFilter = this.mColorFilter;
|
|
if (colorFilter == null) {
|
|
colorFilter = this.mTintFilter;
|
|
}
|
|
canvas.getMatrix(this.mTmpMatrix);
|
|
this.mTmpMatrix.getValues(this.mTmpFloats);
|
|
float abs = Math.abs(this.mTmpFloats[0]);
|
|
float abs2 = Math.abs(this.mTmpFloats[4]);
|
|
float abs3 = Math.abs(this.mTmpFloats[1]);
|
|
float abs4 = Math.abs(this.mTmpFloats[3]);
|
|
if (!(abs3 == 0.0f && abs4 == 0.0f)) {
|
|
abs = 1.0f;
|
|
abs2 = 1.0f;
|
|
}
|
|
int min = Math.min(2048, (int) (((float) this.mTmpBounds.width()) * abs));
|
|
int min2 = Math.min(2048, (int) (((float) this.mTmpBounds.height()) * abs2));
|
|
if (min > 0 && min2 > 0) {
|
|
int save = canvas.save();
|
|
Rect rect = this.mTmpBounds;
|
|
canvas.translate((float) rect.left, (float) rect.top);
|
|
if (needMirroring()) {
|
|
canvas.translate((float) this.mTmpBounds.width(), 0.0f);
|
|
canvas.scale(-1.0f, 1.0f);
|
|
}
|
|
this.mTmpBounds.offsetTo(0, 0);
|
|
this.mVectorState.createCachedBitmapIfNeeded(min, min2);
|
|
if (!this.mAllowCaching) {
|
|
this.mVectorState.updateCachedBitmap(min, min2);
|
|
} else if (!this.mVectorState.canReuseCache()) {
|
|
this.mVectorState.updateCachedBitmap(min, min2);
|
|
this.mVectorState.updateCacheStates();
|
|
}
|
|
this.mVectorState.drawCachedBitmapWithRootAlpha(canvas, colorFilter, this.mTmpBounds);
|
|
canvas.restoreToCount(save);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getAlpha() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? DrawableCompat.getAlpha(drawable) : this.mVectorState.mVPathRenderer.getRootAlpha();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getChangingConfigurations() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? drawable.getChangingConfigurations() : super.getChangingConfigurations() | this.mVectorState.getChangingConfigurations();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public ColorFilter getColorFilter() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? DrawableCompat.getColorFilter(drawable) : this.mColorFilter;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public Drawable.ConstantState getConstantState() {
|
|
if (this.mDelegateDrawable != null && Build.VERSION.SDK_INT >= 24) {
|
|
return new VectorDrawableDelegateState(this.mDelegateDrawable.getConstantState());
|
|
}
|
|
this.mVectorState.mChangingConfigurations = getChangingConfigurations();
|
|
return this.mVectorState;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ Drawable getCurrent() {
|
|
return super.getCurrent();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getIntrinsicHeight() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? drawable.getIntrinsicHeight() : (int) this.mVectorState.mVPathRenderer.mBaseHeight;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getIntrinsicWidth() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? drawable.getIntrinsicWidth() : (int) this.mVectorState.mVPathRenderer.mBaseWidth;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ int getMinimumHeight() {
|
|
return super.getMinimumHeight();
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ int getMinimumWidth() {
|
|
return super.getMinimumWidth();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public int getOpacity() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
return drawable.getOpacity();
|
|
}
|
|
return -3;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ boolean getPadding(Rect rect) {
|
|
return super.getPadding(rect);
|
|
}
|
|
|
|
@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
|
|
public float getPixelSize() {
|
|
VPathRenderer vPathRenderer;
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
if (vectorDrawableCompatState == null || (vPathRenderer = vectorDrawableCompatState.mVPathRenderer) == null) {
|
|
return 1.0f;
|
|
}
|
|
float f = vPathRenderer.mBaseWidth;
|
|
if (f == 0.0f) {
|
|
return 1.0f;
|
|
}
|
|
float f2 = vPathRenderer.mBaseHeight;
|
|
if (f2 == 0.0f) {
|
|
return 1.0f;
|
|
}
|
|
float f3 = vPathRenderer.mViewportHeight;
|
|
if (f3 == 0.0f) {
|
|
return 1.0f;
|
|
}
|
|
float f4 = vPathRenderer.mViewportWidth;
|
|
if (f4 == 0.0f) {
|
|
return 1.0f;
|
|
}
|
|
return Math.min(f4 / f, f3 / f2);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ int[] getState() {
|
|
return super.getState();
|
|
}
|
|
|
|
public Object getTargetByName(String str) {
|
|
return this.mVectorState.mVPathRenderer.mVGTargetsMap.get(str);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ Region getTransparentRegion() {
|
|
return super.getTransparentRegion();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet) throws XmlPullParserException, IOException {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.inflate(resources, xmlPullParser, attributeSet);
|
|
} else {
|
|
inflate(resources, xmlPullParser, attributeSet, null);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void inflate(Resources resources, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) throws XmlPullParserException, IOException {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.inflate(drawable, resources, xmlPullParser, attributeSet, theme);
|
|
return;
|
|
}
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
vectorDrawableCompatState.mVPathRenderer = new VPathRenderer();
|
|
TypedArray obtainAttributes = TypedArrayUtils.obtainAttributes(resources, theme, attributeSet, AndroidResources.STYLEABLE_VECTOR_DRAWABLE_TYPE_ARRAY);
|
|
updateStateFromTypedArray(obtainAttributes, xmlPullParser, theme);
|
|
obtainAttributes.recycle();
|
|
vectorDrawableCompatState.mChangingConfigurations = getChangingConfigurations();
|
|
vectorDrawableCompatState.mCacheDirty = true;
|
|
inflateInternal(resources, xmlPullParser, attributeSet, theme);
|
|
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, vectorDrawableCompatState.mTintMode);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void invalidateSelf() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.invalidateSelf();
|
|
} else {
|
|
super.invalidateSelf();
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean isAutoMirrored() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? DrawableCompat.isAutoMirrored(drawable) : this.mVectorState.mAutoMirrored;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean isStateful() {
|
|
VectorDrawableCompatState vectorDrawableCompatState;
|
|
ColorStateList colorStateList;
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? drawable.isStateful() : super.isStateful() || ((vectorDrawableCompatState = this.mVectorState) != null && (vectorDrawableCompatState.isStateful() || ((colorStateList = this.mVectorState.mTint) != null && colorStateList.isStateful())));
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void jumpToCurrentState() {
|
|
super.jumpToCurrentState();
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public Drawable mutate() {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.mutate();
|
|
return this;
|
|
}
|
|
if (!this.mMutated && super.mutate() == this) {
|
|
this.mVectorState = new VectorDrawableCompatState(this.mVectorState);
|
|
this.mMutated = true;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public void onBoundsChange(Rect rect) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.setBounds(rect);
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean onStateChange(int[] iArr) {
|
|
PorterDuff.Mode mode;
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
return drawable.setState(iArr);
|
|
}
|
|
boolean z2 = false;
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
ColorStateList colorStateList = vectorDrawableCompatState.mTint;
|
|
if (!(colorStateList == null || (mode = vectorDrawableCompatState.mTintMode) == null)) {
|
|
this.mTintFilter = updateTintFilter(this.mTintFilter, colorStateList, mode);
|
|
invalidateSelf();
|
|
z2 = true;
|
|
}
|
|
if (!vectorDrawableCompatState.isStateful() || !vectorDrawableCompatState.onStateChanged(iArr)) {
|
|
return z2;
|
|
}
|
|
invalidateSelf();
|
|
return true;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void scheduleSelf(Runnable runnable, long j) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.scheduleSelf(runnable, j);
|
|
} else {
|
|
super.scheduleSelf(runnable, j);
|
|
}
|
|
}
|
|
|
|
public void setAllowCaching(boolean z2) {
|
|
this.mAllowCaching = z2;
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setAlpha(int i) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.setAlpha(i);
|
|
} else if (this.mVectorState.mVPathRenderer.getRootAlpha() != i) {
|
|
this.mVectorState.mVPathRenderer.setRootAlpha(i);
|
|
invalidateSelf();
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setAutoMirrored(boolean z2) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.setAutoMirrored(drawable, z2);
|
|
} else {
|
|
this.mVectorState.mAutoMirrored = z2;
|
|
}
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void setChangingConfigurations(int i) {
|
|
super.setChangingConfigurations(i);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void setColorFilter(int i, PorterDuff.Mode mode) {
|
|
super.setColorFilter(i, mode);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void setColorFilter(ColorFilter colorFilter) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.setColorFilter(colorFilter);
|
|
return;
|
|
}
|
|
this.mColorFilter = colorFilter;
|
|
invalidateSelf();
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void setFilterBitmap(boolean z2) {
|
|
super.setFilterBitmap(z2);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void setHotspot(float f, float f2) {
|
|
super.setHotspot(f, f2);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ void setHotspotBounds(int i, int i2, int i3, int i4) {
|
|
super.setHotspotBounds(i, i2, i3, i4);
|
|
}
|
|
|
|
@Override // androidx.vectordrawable.graphics.drawable.VectorDrawableCommon, android.graphics.drawable.Drawable
|
|
public /* bridge */ /* synthetic */ boolean setState(int[] iArr) {
|
|
return super.setState(iArr);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
|
|
public void setTint(int i) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.setTint(drawable, i);
|
|
} else {
|
|
setTintList(ColorStateList.valueOf(i));
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
|
|
public void setTintList(ColorStateList colorStateList) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.setTintList(drawable, colorStateList);
|
|
return;
|
|
}
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
if (vectorDrawableCompatState.mTint != colorStateList) {
|
|
vectorDrawableCompatState.mTint = colorStateList;
|
|
this.mTintFilter = updateTintFilter(this.mTintFilter, colorStateList, vectorDrawableCompatState.mTintMode);
|
|
invalidateSelf();
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable, androidx.core.graphics.drawable.TintAwareDrawable
|
|
public void setTintMode(PorterDuff.Mode mode) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
DrawableCompat.setTintMode(drawable, mode);
|
|
return;
|
|
}
|
|
VectorDrawableCompatState vectorDrawableCompatState = this.mVectorState;
|
|
if (vectorDrawableCompatState.mTintMode != mode) {
|
|
vectorDrawableCompatState.mTintMode = mode;
|
|
this.mTintFilter = updateTintFilter(this.mTintFilter, vectorDrawableCompatState.mTint, mode);
|
|
invalidateSelf();
|
|
}
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public boolean setVisible(boolean z2, boolean z3) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
return drawable != null ? drawable.setVisible(z2, z3) : super.setVisible(z2, z3);
|
|
}
|
|
|
|
@Override // android.graphics.drawable.Drawable
|
|
public void unscheduleSelf(Runnable runnable) {
|
|
Drawable drawable = this.mDelegateDrawable;
|
|
if (drawable != null) {
|
|
drawable.unscheduleSelf(runnable);
|
|
} else {
|
|
super.unscheduleSelf(runnable);
|
|
}
|
|
}
|
|
|
|
public PorterDuffColorFilter updateTintFilter(PorterDuffColorFilter porterDuffColorFilter, ColorStateList colorStateList, PorterDuff.Mode mode) {
|
|
if (colorStateList == null || mode == null) {
|
|
return null;
|
|
}
|
|
return new PorterDuffColorFilter(colorStateList.getColorForState(getState(), 0), mode);
|
|
}
|
|
}
|