package carbon.widget;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ValueAnimator;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.TypedArray;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Outline;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.util.AttributeSet;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewAnimationUtils;
import android.view.ViewGroup;
import android.view.ViewOutlineProvider;
import androidx.annotation.AttrRes;
import androidx.annotation.FloatRange;
import androidx.annotation.LayoutRes;
import androidx.annotation.NonNull;
import androidx.annotation.StyleRes;
import androidx.core.view.GravityCompat;
import androidx.core.view.ViewCompat;
import com.annimon.stream.Stream;
import com.google.android.material.shape.CutCornerTreatment;
import com.google.android.material.shape.MaterialShapeDrawable;
import com.google.android.material.shape.RoundedCornerTreatment;
import com.google.android.material.shape.ShapeAppearanceModel;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import carbon.Carbon;
import carbon.R;
import carbon.animation.AnimatedView;
import carbon.animation.StateAnimator;
import carbon.behavior.Behavior;
import carbon.component.Component;
import carbon.component.ComponentView;
import carbon.drawable.ripple.RippleDrawable;
import carbon.drawable.ripple.RippleView;
import carbon.internal.ElevationComparator;
import carbon.internal.RevealAnimator;
import carbon.view.BehaviorView;
import carbon.view.InsetView;
import carbon.view.MarginView;
import carbon.view.MaxSizeView;
import carbon.view.RevealView;
import carbon.view.ShadowView;
import carbon.view.ShapeModelView;
import carbon.view.StateAnimatorView;
import carbon.view.StrokeView;
import carbon.view.TouchMarginView;
import carbon.view.TransformationView;
import carbon.view.VisibleView;
/**
* A FrameLayout implementation with support for material features including shadows, ripples,
* rounded corners, insets, custom drawing order, touch margins, state animators and others.
*/
public class FrameLayout extends android.widget.FrameLayout
implements
ShadowView,
RippleView,
TouchMarginView,
StateAnimatorView,
AnimatedView,
ShapeModelView,
InsetView,
StrokeView,
MaxSizeView,
RevealView,
VisibleView,
TransformationView,
BehaviorView,
MarginView {
private OnTouchListener onDispatchTouchListener;
public FrameLayout(Context context) {
super(context, null, R.attr.carbon_frameLayoutStyle);
initFrameLayout(null, R.attr.carbon_frameLayoutStyle, R.style.carbon_FrameLayout);
}
public FrameLayout(Context context, AttributeSet attrs) {
super(context, attrs, R.attr.carbon_frameLayoutStyle);
initFrameLayout(attrs, R.attr.carbon_frameLayoutStyle, R.style.carbon_FrameLayout);
}
public FrameLayout(Context context, AttributeSet attrs, @AttrRes int defStyleAttr) {
super(context, attrs, defStyleAttr);
initFrameLayout(attrs, defStyleAttr, R.style.carbon_FrameLayout);
}
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public FrameLayout(Context context, AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
initFrameLayout(attrs, defStyleAttr, defStyleRes);
}
private static int[] rippleIds = new int[]{
R.styleable.FrameLayout_carbon_rippleColor,
R.styleable.FrameLayout_carbon_rippleStyle,
R.styleable.FrameLayout_carbon_rippleHotspot,
R.styleable.FrameLayout_carbon_rippleRadius
};
private static int[] animationIds = new int[]{
R.styleable.FrameLayout_carbon_inAnimation,
R.styleable.FrameLayout_carbon_outAnimation
};
private static int[] touchMarginIds = new int[]{
R.styleable.FrameLayout_carbon_touchMargin,
R.styleable.FrameLayout_carbon_touchMarginLeft,
R.styleable.FrameLayout_carbon_touchMarginTop,
R.styleable.FrameLayout_carbon_touchMarginRight,
R.styleable.FrameLayout_carbon_touchMarginBottom
};
private static int[] insetIds = new int[]{
R.styleable.FrameLayout_carbon_inset,
R.styleable.FrameLayout_carbon_insetLeft,
R.styleable.FrameLayout_carbon_insetTop,
R.styleable.FrameLayout_carbon_insetRight,
R.styleable.FrameLayout_carbon_insetBottom,
R.styleable.FrameLayout_carbon_insetColor
};
private static int[] strokeIds = new int[]{
R.styleable.FrameLayout_carbon_stroke,
R.styleable.FrameLayout_carbon_strokeWidth
};
private static int[] cornerCutRadiusIds = new int[]{
R.styleable.FrameLayout_carbon_cornerRadiusTopStart,
R.styleable.FrameLayout_carbon_cornerRadiusTopEnd,
R.styleable.FrameLayout_carbon_cornerRadiusBottomStart,
R.styleable.FrameLayout_carbon_cornerRadiusBottomEnd,
R.styleable.FrameLayout_carbon_cornerRadius,
R.styleable.FrameLayout_carbon_cornerCutTopStart,
R.styleable.FrameLayout_carbon_cornerCutTopEnd,
R.styleable.FrameLayout_carbon_cornerCutBottomStart,
R.styleable.FrameLayout_carbon_cornerCutBottomEnd,
R.styleable.FrameLayout_carbon_cornerCut
};
private static int[] maxSizeIds = new int[]{
R.styleable.FrameLayout_carbon_maxWidth,
R.styleable.FrameLayout_carbon_maxHeight,
};
private static int[] elevationIds = new int[]{
R.styleable.FrameLayout_carbon_elevation,
R.styleable.FrameLayout_carbon_elevationShadowColor,
R.styleable.FrameLayout_carbon_elevationAmbientShadowColor,
R.styleable.FrameLayout_carbon_elevationSpotShadowColor
};
private void initFrameLayout(AttributeSet attrs, @AttrRes int defStyleAttr, @StyleRes int defStyleRes) {
TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.FrameLayout, defStyleAttr, defStyleRes);
Carbon.initDefaultBackground(this, a, R.styleable.FrameLayout_android_background);
Carbon.initElevation(this, a, elevationIds);
Carbon.initRippleDrawable(this, a, rippleIds);
Carbon.initAnimations(this, a, animationIds);
Carbon.initTouchMargin(this, a, touchMarginIds);
Carbon.initInset(this, a, insetIds);
Carbon.initMaxSize(this, a, maxSizeIds);
Carbon.initStroke(this, a, strokeIds);
Carbon.initCornerCutRadius(this, a, cornerCutRadiusIds);
a.recycle();
setChildrenDrawingOrderEnabled(true);
setClipToPadding(false);
}
private Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
private boolean drawCalled = false;
RevealAnimator revealAnimator;
public Point getLocationOnScreen() {
int[] outLocation = new int[2];
super.getLocationOnScreen(outLocation);
return new Point(outLocation[0], outLocation[1]);
}
public Point getLocationInWindow() {
int[] outLocation = new int[2];
super.getLocationInWindow(outLocation);
return new Point(outLocation[0], outLocation[1]);
}
@NotNull
public Animator createCircularReveal(android.view.View hotspot, float startRadius, float finishRadius) {
int[] location = new int[2];
hotspot.getLocationOnScreen(location);
int[] myLocation = new int[2];
getLocationOnScreen(myLocation);
return createCircularReveal(location[0] - myLocation[0] + hotspot.getWidth() / 2, location[1] - myLocation[1] + hotspot.getHeight() / 2, startRadius, finishRadius);
}
@NotNull
@Override
public Animator createCircularReveal(int x, int y, float startRadius, float finishRadius) {
startRadius = Carbon.getRevealRadius(this, x, y, startRadius);
finishRadius = Carbon.getRevealRadius(this, x, y, finishRadius);
if (Carbon.IS_LOLLIPOP_OR_HIGHER) {
Animator circularReveal = ViewAnimationUtils.createCircularReveal(this, x, y, startRadius, finishRadius);
circularReveal.setDuration(Carbon.getDefaultRevealDuration());
return circularReveal;
} else {
revealAnimator = new RevealAnimator(x, y, startRadius, finishRadius);
revealAnimator.setDuration(Carbon.getDefaultRevealDuration());
revealAnimator.addUpdateListener(animation -> {
RevealAnimator reveal = ((RevealAnimator) animation);
reveal.radius = (float) reveal.getAnimatedValue();
reveal.mask.reset();
reveal.mask.addCircle(reveal.x, reveal.y, Math.max((Float) reveal.getAnimatedValue(), 1), Path.Direction.CW);
postInvalidate();
});
revealAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationCancel(Animator animation) {
revealAnimator = null;
}
@Override
public void onAnimationEnd(Animator animation) {
revealAnimator = null;
}
});
return revealAnimator;
}
}
@Override
protected void dispatchDraw(@NonNull Canvas canvas) {
boolean r = revealAnimator != null && revealAnimator.isRunning();
boolean c = !Carbon.isShapeRect(shapeModel, boundsRect);
if (Carbon.IS_PIE_OR_HIGHER) {
if (spotShadowColor != null)
super.setOutlineSpotShadowColor(spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor()));
if (ambientShadowColor != null)
super.setOutlineAmbientShadowColor(ambientShadowColor.getColorForState(getDrawableState(), ambientShadowColor.getDefaultColor()));
}
// draw not called, we have to handle corners here
if (isInEditMode() && !drawCalled && (r || c) && getWidth() > 0 && getHeight() > 0) {
Bitmap layer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
Canvas layerCanvas = new Canvas(layer);
dispatchDrawInternal(layerCanvas);
Bitmap mask = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
Canvas maskCanvas = new Canvas(mask);
Paint maskPaint = new Paint(0xffffffff);
maskCanvas.drawPath(cornersMask, maskPaint);
for (int x = 0; x < getWidth(); x++) {
for (int y = 0; y < getHeight(); y++) {
int maskPixel = mask.getPixel(x, y);
layer.setPixel(x, y, Color.alpha(maskPixel) > 0 ? layer.getPixel(x, y) : 0);
}
}
canvas.drawBitmap(layer, 0, 0, paint);
} else if (!drawCalled && (r || c) && getWidth() > 0 && getHeight() > 0 && !Carbon.IS_LOLLIPOP_OR_HIGHER) {
int saveCount = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG);
if (r) {
int saveCount2 = canvas.save();
canvas.clipRect(revealAnimator.x - revealAnimator.radius, revealAnimator.y - revealAnimator.radius, revealAnimator.x + revealAnimator.radius, revealAnimator.y + revealAnimator.radius);
dispatchDrawInternal(canvas);
canvas.restoreToCount(saveCount2);
} else {
dispatchDrawInternal(canvas);
}
paint.setXfermode(Carbon.CLEAR_MODE);
if (c) {
cornersMask.setFillType(Path.FillType.INVERSE_WINDING);
canvas.drawPath(cornersMask, paint);
}
if (r)
canvas.drawPath(revealAnimator.mask, paint);
paint.setXfermode(null);
canvas.restoreToCount(saveCount);
} else {
dispatchDrawInternal(canvas);
}
drawCalled = false;
}
private void dispatchDrawInternal(@NonNull Canvas canvas) {
Collections.sort(getViews(), new ElevationComparator());
super.dispatchDraw(canvas);
if (stroke != null)
drawStroke(canvas);
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Over)
rippleDrawable.draw(canvas);
if (insetColor != 0) {
paint.setColor(insetColor);
paint.setAlpha(255);
if (insetLeft != 0)
canvas.drawRect(0, 0, insetLeft, getHeight(), paint);
if (insetTop != 0)
canvas.drawRect(0, 0, getWidth(), insetTop, paint);
if (insetRight != 0)
canvas.drawRect(getWidth() - insetRight, 0, getWidth(), getHeight(), paint);
if (insetBottom != 0)
canvas.drawRect(0, getHeight() - insetBottom, getWidth(), getHeight(), paint);
}
}
@Override
protected boolean drawChild(@NonNull Canvas canvas, @NonNull View child, long drawingTime) {
// TODO: why isShown() returns false after being reattached?
if (child instanceof ShadowView && (!Carbon.IS_LOLLIPOP_OR_HIGHER || ((ShadowView) child).getElevationShadowColor() != null && !Carbon.IS_PIE_OR_HIGHER)) {
ShadowView shadowView = (ShadowView) child;
shadowView.drawShadow(canvas);
}
if (child instanceof RippleView) {
RippleView rippleView = (RippleView) child;
RippleDrawable rippleDrawable = rippleView.getRippleDrawable();
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless) {
int saveCount = canvas.save();
canvas.translate(child.getLeft(), child.getTop());
canvas.concat(child.getMatrix());
rippleDrawable.draw(canvas);
canvas.restoreToCount(saveCount);
}
}
return super.drawChild(canvas, child, drawingTime);
}
@Override
protected int getChildDrawingOrder(int childCount, int child) {
if (views.size() != childCount)
getViews();
return indexOfChild(views.get(child));
}
protected boolean isTransformedTouchPointInView(float x, float y, View child, PointF outLocalPoint) {
final Rect frame = new Rect();
child.getHitRect(frame);
return frame.contains((int) x, (int) y);
}
// -------------------------------
// corners
// -------------------------------
private RectF boundsRect = new RectF();
private Path cornersMask = new Path();
@NotNull
public ShapeAppearanceModel getShapeModel() {
return shapeModel;
}
/**
* Sets the corner radius. If corner radius is equal to 0, rounded corners are turned off.
*
* @param cornerRadius
*/
@Override
public void setCornerRadius(float cornerRadius) {
shapeModel = ShapeAppearanceModel.builder().setAllCorners(new RoundedCornerTreatment(cornerRadius)).build();
setShapeModel(shapeModel);
}
@Override
public void setCornerCut(float cornerCut) {
shapeModel = ShapeAppearanceModel.builder().setAllCorners(new CutCornerTreatment(cornerCut)).build();
setShapeModel(shapeModel);
}
@Override
public void setShapeModel(@NotNull ShapeAppearanceModel model) {
this.shapeModel = model;
shadowDrawable = new MaterialShapeDrawable(shapeModel);
if (getWidth() > 0 && getHeight() > 0)
updateCorners();
if (!Carbon.IS_LOLLIPOP_OR_HIGHER)
postInvalidate();
}
@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
super.onLayout(changed, left, top, right, bottom);
layoutAnchoredViews();
if (!changed)
return;
if (getWidth() == 0 || getHeight() == 0)
return;
updateCorners();
if (rippleDrawable != null)
rippleDrawable.setBounds(0, 0, getWidth(), getHeight());
}
private void updateCorners() {
if (Carbon.IS_LOLLIPOP_OR_HIGHER) {
setClipToOutline(true);
setOutlineProvider(new ViewOutlineProvider() {
@Override
public void getOutline(View view, Outline outline) {
if (Carbon.isShapeRect(shapeModel, boundsRect)) {
outline.setRect(0, 0, getWidth(), getHeight());
} else {
shadowDrawable.setBounds(0, 0, getWidth(), getHeight());
shadowDrawable.setShadowCompatibilityMode(MaterialShapeDrawable.SHADOW_COMPAT_MODE_NEVER);
shadowDrawable.getOutline(outline);
}
}
});
}
boundsRect.set(shadowDrawable.getBounds());
shadowDrawable.getPathForSize(getWidth(), getHeight(), cornersMask);
}
public void drawInternal(@NonNull Canvas canvas) {
super.draw(canvas);
if (stroke != null)
drawStroke(canvas);
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Over)
rippleDrawable.draw(canvas);
}
@SuppressLint("MissingSuperCall")
@Override
public void draw(@NonNull Canvas canvas) {
drawCalled = true;
boolean r = revealAnimator != null;
boolean c = !Carbon.isShapeRect(shapeModel, boundsRect);
if (Carbon.IS_PIE_OR_HIGHER) {
if (spotShadowColor != null)
super.setOutlineSpotShadowColor(spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor()));
if (ambientShadowColor != null)
super.setOutlineAmbientShadowColor(ambientShadowColor.getColorForState(getDrawableState(), ambientShadowColor.getDefaultColor()));
}
if (isInEditMode() && (r || c) && getWidth() > 0 && getHeight() > 0) {
Bitmap layer = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
Canvas layerCanvas = new Canvas(layer);
drawInternal(layerCanvas);
Bitmap mask = Bitmap.createBitmap(getWidth(), getHeight(), Bitmap.Config.ARGB_8888);
Canvas maskCanvas = new Canvas(mask);
Paint maskPaint = new Paint(0xffffffff);
maskCanvas.drawPath(cornersMask, maskPaint);
for (int x = 0; x < getWidth(); x++) {
for (int y = 0; y < getHeight(); y++) {
int maskPixel = mask.getPixel(x, y);
layer.setPixel(x, y, Color.alpha(maskPixel) > 0 ? layer.getPixel(x, y) : 0);
}
}
canvas.drawBitmap(layer, 0, 0, paint);
} else if (getWidth() > 0 && getHeight() > 0 && (((r || c) && !Carbon.IS_LOLLIPOP_OR_HIGHER) || !shapeModel.isRoundRect(boundsRect))) {
int saveCount = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, Canvas.ALL_SAVE_FLAG);
if (r) {
int saveCount2 = canvas.save();
canvas.clipRect(revealAnimator.x - revealAnimator.radius, revealAnimator.y - revealAnimator.radius, revealAnimator.x + revealAnimator.radius, revealAnimator.y + revealAnimator.radius);
drawInternal(canvas);
canvas.restoreToCount(saveCount2);
} else {
drawInternal(canvas);
}
paint.setXfermode(Carbon.CLEAR_MODE);
if (c) {
cornersMask.setFillType(Path.FillType.INVERSE_WINDING);
canvas.drawPath(cornersMask, paint);
}
if (r)
canvas.drawPath(revealAnimator.mask, paint);
paint.setXfermode(null);
canvas.restoreToCount(saveCount);
paint.setXfermode(null);
} else {
drawInternal(canvas);
}
}
// -------------------------------
// ripple
// -------------------------------
private RippleDrawable rippleDrawable;
@Override
public boolean dispatchTouchEvent(@NonNull MotionEvent event) {
if (shadowDrawable.isPointInTransparentRegion((int) event.getX(), (int) event.getY()))
return false;
if (onDispatchTouchListener != null && onDispatchTouchListener.onTouch(this, event))
return true;
if (rippleDrawable != null && event.getAction() == MotionEvent.ACTION_DOWN)
rippleDrawable.setHotspot(event.getX(), event.getY());
return super.dispatchTouchEvent(event);
}
@Override
public RippleDrawable getRippleDrawable() {
return rippleDrawable;
}
@Override
public void setRippleDrawable(RippleDrawable newRipple) {
if (rippleDrawable != null) {
rippleDrawable.setCallback(null);
if (rippleDrawable.getStyle() == RippleDrawable.Style.Background)
super.setBackgroundDrawable(rippleDrawable.getBackground());
}
if (newRipple != null) {
newRipple.setCallback(this);
newRipple.setBounds(0, 0, getWidth(), getHeight());
newRipple.setState(getDrawableState());
((Drawable) newRipple).setVisible(getVisibility() == VISIBLE, false);
if (newRipple.getStyle() == RippleDrawable.Style.Background)
super.setBackgroundDrawable((Drawable) newRipple);
}
rippleDrawable = newRipple;
}
@Override
protected boolean verifyDrawable(@NonNull Drawable who) {
return super.verifyDrawable(who) || rippleDrawable == who;
}
@Override
public void invalidateDrawable(@NonNull Drawable drawable) {
super.invalidateDrawable(drawable);
invalidateParentIfNeeded();
}
@Override
public void invalidate(@NonNull Rect dirty) {
super.invalidate(dirty);
invalidateParentIfNeeded();
}
@Override
public void invalidate(int l, int t, int r, int b) {
super.invalidate(l, t, r, b);
invalidateParentIfNeeded();
}
@Override
public void invalidate() {
super.invalidate();
invalidateParentIfNeeded();
}
private void invalidateParentIfNeeded() {
if (getParent() == null || !(getParent() instanceof View))
return;
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless)
((View) getParent()).invalidate();
if (elevation > 0 || !Carbon.isShapeRect(shapeModel, boundsRect))
((View) getParent()).invalidate();
}
@Override
public void postInvalidateDelayed(long delayMilliseconds) {
super.postInvalidateDelayed(delayMilliseconds);
postInvalidateParentIfNeededDelayed(delayMilliseconds);
}
@Override
public void postInvalidateDelayed(long delayMilliseconds, int left, int top, int right, int bottom) {
super.postInvalidateDelayed(delayMilliseconds, left, top, right, bottom);
postInvalidateParentIfNeededDelayed(delayMilliseconds);
}
private void postInvalidateParentIfNeededDelayed(long delayMilliseconds) {
if (getParent() == null || !(getParent() instanceof View))
return;
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Borderless)
((View) getParent()).postInvalidateDelayed(delayMilliseconds);
if (elevation > 0 || !Carbon.isShapeRect(shapeModel, boundsRect))
((View) getParent()).postInvalidateDelayed(delayMilliseconds);
}
@Override
public void setBackground(Drawable background) {
setBackgroundDrawable(background);
}
@Override
public void setBackgroundDrawable(Drawable background) {
if (background instanceof RippleDrawable) {
setRippleDrawable((RippleDrawable) background);
return;
}
if (rippleDrawable != null && rippleDrawable.getStyle() == RippleDrawable.Style.Background) {
rippleDrawable.setCallback(null);
rippleDrawable = null;
}
super.setBackgroundDrawable(background);
}
// -------------------------------
// elevation
// -------------------------------
private float elevation = 0;
private float translationZ = 0;
private ShapeAppearanceModel shapeModel = new ShapeAppearanceModel();
private MaterialShapeDrawable shadowDrawable = new MaterialShapeDrawable(shapeModel);
private ColorStateList ambientShadowColor, spotShadowColor;
@Override
public float getElevation() {
return elevation;
}
@Override
public void setElevation(float elevation) {
if (Carbon.IS_PIE_OR_HIGHER) {
super.setElevation(elevation);
super.setTranslationZ(translationZ);
} else if (Carbon.IS_LOLLIPOP_OR_HIGHER) {
if (ambientShadowColor == null || spotShadowColor == null) {
super.setElevation(elevation);
super.setTranslationZ(translationZ);
} else {
super.setElevation(0);
super.setTranslationZ(0);
}
} else if (elevation != this.elevation && getParent() != null) {
((View) getParent()).postInvalidate();
}
this.elevation = elevation;
}
@Override
public float getTranslationZ() {
return translationZ;
}
public void setTranslationZ(float translationZ) {
if (translationZ == this.translationZ)
return;
if (Carbon.IS_PIE_OR_HIGHER) {
super.setTranslationZ(translationZ);
} else if (Carbon.IS_LOLLIPOP_OR_HIGHER) {
if (ambientShadowColor == null || spotShadowColor == null) {
super.setTranslationZ(translationZ);
} else {
super.setTranslationZ(0);
}
} else if (translationZ != this.translationZ && getParent() != null) {
((View) getParent()).postInvalidate();
}
this.translationZ = translationZ;
}
@Override
public void setEnabled(boolean enabled) {
super.setEnabled(enabled);
}
@Override
public boolean hasShadow() {
return getElevation() + getTranslationZ() >= 0.01f && getWidth() > 0 && getHeight() > 0;
}
@Override
public void drawShadow(@NotNull Canvas canvas) {
float alpha = getAlpha() * Carbon.getBackgroundTintAlpha(this) / 255.0f;
if (alpha == 0 || !hasShadow())
return;
float z = getElevation() + getTranslationZ();
int saveCount;
boolean maskShadow = getBackground() != null && alpha != 1;
boolean r = revealAnimator != null && revealAnimator.isRunning();
if (alpha != 255) {
paint.setAlpha((int) (127 * alpha));
saveCount = canvas.saveLayer(0, 0, canvas.getWidth(), canvas.getHeight(), paint, Canvas.ALL_SAVE_FLAG);
} else {
saveCount = canvas.save();
}
Matrix matrix = getMatrix();
canvas.setMatrix(matrix);
if (r) {
canvas.clipRect(
getLeft() + revealAnimator.x - revealAnimator.radius, getTop() + revealAnimator.y - revealAnimator.radius,
getLeft() + revealAnimator.x + revealAnimator.radius, getTop() + revealAnimator.y + revealAnimator.radius);
}
shadowDrawable.setFillColor(spotShadowColor);
shadowDrawable.setShadowColor(spotShadowColor != null ? spotShadowColor.getColorForState(getDrawableState(), spotShadowColor.getDefaultColor()) : 0xff000000);
shadowDrawable.setShadowCompatibilityMode(MaterialShapeDrawable.SHADOW_COMPAT_MODE_ALWAYS);
shadowDrawable.setAlpha(0x44);
shadowDrawable.setElevation(z);
shadowDrawable.setShadowVerticalOffset(0);
shadowDrawable.setBounds(getLeft(), (int) (getTop() + z / 4), getRight(), (int) (getBottom() + z / 4));
shadowDrawable.draw(canvas);
canvas.translate(this.getLeft(), this.getTop());
canvas.concat(matrix);
paint.setXfermode(Carbon.CLEAR_MODE);
if (maskShadow) {
cornersMask.setFillType(Path.FillType.WINDING);
canvas.drawPath(cornersMask, paint);
}
if (r)
canvas.drawPath(revealAnimator.mask, paint);
canvas.restoreToCount(saveCount);
paint.setXfermode(null);
paint.setAlpha(255);
}
@Override
public void setElevationShadowColor(ColorStateList shadowColor) {
ambientShadowColor = spotShadowColor = shadowColor;
setElevation(elevation);
setTranslationZ(translationZ);
}
@Override
public void setElevationShadowColor(int color) {
ambientShadowColor = spotShadowColor = ColorStateList.valueOf(color);
setElevation(elevation);
setTranslationZ(translationZ);
}
@Override
public ColorStateList getElevationShadowColor() {
return ambientShadowColor;
}
@Override
public void setOutlineAmbientShadowColor(int color) {
setOutlineAmbientShadowColor(ColorStateList.valueOf(color));
}
@Override
public void setOutlineAmbientShadowColor(ColorStateList color) {
ambientShadowColor = color;
if (Carbon.IS_PIE_OR_HIGHER) {
super.setOutlineAmbientShadowColor(color.getColorForState(getDrawableState(), color.getDefaultColor()));
} else {
setElevation(elevation);
setTranslationZ(translationZ);
}
}
@Override
public int getOutlineAmbientShadowColor() {
return ambientShadowColor.getDefaultColor();
}
@Override
public void setOutlineSpotShadowColor(int color) {
setOutlineSpotShadowColor(ColorStateList.valueOf(color));
}
@Override
public void setOutlineSpotShadowColor(ColorStateList color) {
spotShadowColor = color;
if (Carbon.IS_PIE_OR_HIGHER) {
super.setOutlineSpotShadowColor(color.getColorForState(getDrawableState(), color.getDefaultColor()));
} else {
setElevation(elevation);
setTranslationZ(translationZ);
}
}
@Override
public int getOutlineSpotShadowColor() {
return spotShadowColor.getDefaultColor();
}
// -------------------------------
// touch margin
// -------------------------------
private Rect touchMargin = new Rect();
@Override
public void setTouchMargin(int left, int top, int right, int bottom) {
touchMargin.set(left, top, right, bottom);
}
@Override
public void setTouchMarginLeft(int margin) {
touchMargin.left = margin;
}
@Override
public void setTouchMarginTop(int margin) {
touchMargin.top = margin;
}
@Override
public void setTouchMarginRight(int margin) {
touchMargin.right = margin;
}
@Override
public void setTouchMarginBottom(int margin) {
touchMargin.bottom = margin;
}
@NotNull
@Override
public Rect getTouchMargin() {
return touchMargin;
}
final RectF tmpHitRect = new RectF();
public void getHitRect(@NonNull Rect outRect) {
Matrix matrix = getMatrix();
if (matrix.isIdentity()) {
outRect.set(getLeft(), getTop(), getRight(), getBottom());
} else {
tmpHitRect.set(0, 0, getWidth(), getHeight());
matrix.mapRect(tmpHitRect);
outRect.set((int) tmpHitRect.left + getLeft(), (int) tmpHitRect.top + getTop(),
(int) tmpHitRect.right + getLeft(), (int) tmpHitRect.bottom + getTop());
}
outRect.left -= touchMargin.left;
outRect.top -= touchMargin.top;
outRect.right += touchMargin.right;
outRect.bottom += touchMargin.bottom;
}
// -------------------------------
// state animators
// -------------------------------
private StateAnimator stateAnimator = new StateAnimator(this);
@NotNull
@Override
public StateAnimator getStateAnimator() {
return stateAnimator;
}
@Override
protected void drawableStateChanged() {
super.drawableStateChanged();
if (rippleDrawable != null && rippleDrawable.getStyle() != RippleDrawable.Style.Background)
rippleDrawable.setState(getDrawableState());
if (stateAnimator != null)
stateAnimator.setState(getDrawableState());
}
// -------------------------------
// animations
// -------------------------------
private Animator inAnim = null, outAnim = null;
private Animator animator;
public Animator animateVisibility(final int visibility) {
if (visibility == View.VISIBLE && (getVisibility() != View.VISIBLE || animator != null)) {
if (animator != null)
animator.cancel();
if (inAnim != null) {
animator = inAnim;
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator a) {
a.removeListener(this);
animator = null;
}
@Override
public void onAnimationCancel(Animator a) {
a.removeListener(this);
animator = null;
}
});
animator.start();
}
setVisibility(visibility);
} else if (visibility != View.VISIBLE && (getVisibility() == View.VISIBLE || animator != null)) {
if (animator != null)
animator.cancel();
if (outAnim == null) {
setVisibility(visibility);
return null;
}
animator = outAnim;
animator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator a) {
if (((ValueAnimator) a).getAnimatedFraction() == 1)
setVisibility(visibility);
a.removeListener(this);
animator = null;
}
@Override
public void onAnimationCancel(Animator a) {
a.removeListener(this);
animator = null;
}
});
animator.start();
} else {
setVisibility(visibility);
}
return animator;
}
public Animator getAnimator() {
return animator;
}
public Animator getOutAnimator() {
return outAnim;
}
public void setOutAnimator(Animator outAnim) {
if (this.outAnim != null)
this.outAnim.setTarget(null);
this.outAnim = outAnim;
if (outAnim != null)
outAnim.setTarget(this);
}
public Animator getInAnimator() {
return inAnim;
}
public void setInAnimator(Animator inAnim) {
if (this.inAnim != null)
this.inAnim.setTarget(null);
this.inAnim = inAnim;
if (inAnim != null)
inAnim.setTarget(this);
}
// -------------------------------
// insets
// -------------------------------
int insetLeft = InsetView.INSET_NULL, insetTop = InsetView.INSET_NULL, insetRight = InsetView.INSET_NULL, insetBottom = InsetView.INSET_NULL;
int insetColor;
private OnInsetsChangedListener onInsetsChangedListener;
public int getInsetColor() {
return insetColor;
}
public void setInsetColor(int insetsColor) {
this.insetColor = insetsColor;
}
public void setInset(int left, int top, int right, int bottom) {
insetLeft = left;
insetTop = top;
insetRight = right;
insetBottom = bottom;
}
public int getInsetLeft() {
return insetLeft;
}
public void setInsetLeft(int insetLeft) {
this.insetLeft = insetLeft;
}
public int getInsetTop() {
return insetTop;
}
public void setInsetTop(int insetTop) {
this.insetTop = insetTop;
}
public int getInsetRight() {
return insetRight;
}
public void setInsetRight(int insetRight) {
this.insetRight = insetRight;
}
public int getInsetBottom() {
return insetBottom;
}
public void setInsetBottom(int insetBottom) {
this.insetBottom = insetBottom;
}
@Override
protected boolean fitSystemWindows(@NonNull Rect insets) {
if (insetLeft == InsetView.INSET_NULL)
insetLeft = insets.left;
if (insetTop == InsetView.INSET_NULL)
insetTop = insets.top;
if (insetRight == InsetView.INSET_NULL)
insetRight = insets.right;
if (insetBottom == InsetView.INSET_NULL)
insetBottom = insets.bottom;
insets.set(insetLeft, insetTop, insetRight, insetBottom);
if (onInsetsChangedListener != null)
onInsetsChangedListener.onInsetsChanged();
postInvalidate();
return super.fitSystemWindows(insets);
}
public void setOnInsetsChangedListener(OnInsetsChangedListener onInsetsChangedListener) {
this.onInsetsChangedListener = onInsetsChangedListener;
}
// -------------------------------
// ViewGroup utils
// -------------------------------
List<View> views = new ArrayList<>();
public List<View> getViews() {
views.clear();
for (int i = 0; i < getChildCount(); i++)
views.add(getChildAt(i));
return views;
}
public void setOnDispatchTouchListener(OnTouchListener onDispatchTouchListener) {
this.onDispatchTouchListener = onDispatchTouchListener;
}
public Component findComponentById(int id) {
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child instanceof ComponentView && ((ComponentView) child).getComponent().getView().getId() == id)
return ((ComponentView) child).getComponent();
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return null;
}
public List<Component> findComponentsById(int id) {
List<Component> result = new ArrayList<>();
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child instanceof ComponentView && ((ComponentView) child).getComponent().getView().getId() == id)
result.add(((ComponentView) child).getComponent());
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return result;
}
public Component findComponentOfType(Class type) {
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child instanceof ComponentView && ((ComponentView) child).getComponent().getClass().equals(type))
return ((ComponentView) child).getComponent();
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return null;
}
public List<Component> findComponentsOfType(Class type) {
List<Component> result = new ArrayList<>();
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child instanceof ComponentView && ((ComponentView) child).getComponent().getClass().equals(type))
result.add(((ComponentView) child).getComponent());
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return result;
}
public <Type extends View> Type findViewOfType(Class<Type> type) {
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child.getClass().equals(type))
return (Type) child;
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return null;
}
public <Type extends View> List<Type> findViewsOfType(Class<Type> type) {
List<Type> result = new ArrayList<>();
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child.getClass().equals(type))
result.add((Type) child);
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return result;
}
public List<View> findViewsById(int id) {
List<View> result = new ArrayList<>();
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (child.getId() == id)
result.add(child);
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return result;
}
public List<View> findViewsWithTag(Object tag) {
List<View> result = new ArrayList<>();
List<ViewGroup> groups = new ArrayList<>();
groups.add(this);
while (!groups.isEmpty()) {
ViewGroup group = groups.remove(0);
for (int i = 0; i < group.getChildCount(); i++) {
View child = group.getChildAt(i);
if (tag.equals(child.getTag()))
result.add(child);
if (child instanceof ViewGroup)
groups.add((ViewGroup) child);
}
}
return result;
}
public View inflate(@LayoutRes int id) {
return LayoutInflater.from(getContext()).inflate(id, this);
}
public View inflate(@LayoutRes int id, boolean attach) {
return LayoutInflater.from(getContext()).inflate(id, this, attach);
}
// -------------------------------
// stroke
// -------------------------------
private ColorStateList stroke;
private float strokeWidth;
private Paint strokePaint;
private void drawStroke(Canvas canvas) {
strokePaint.setStrokeWidth(strokeWidth * 2);
strokePaint.setColor(stroke.getColorForState(getDrawableState(), stroke.getDefaultColor()));
cornersMask.setFillType(Path.FillType.WINDING);
canvas.drawPath(cornersMask, strokePaint);
}
@Override
public void setStroke(ColorStateList colorStateList) {
stroke = colorStateList;
if (stroke == null)
return;
if (strokePaint == null) {
strokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
strokePaint.setStyle(Paint.Style.STROKE);
}
}
@Override
public void setStroke(int color) {
setStroke(ColorStateList.valueOf(color));
}
@Override
public ColorStateList getStroke() {
return stroke;
}
@Override
public void setStrokeWidth(float strokeWidth) {
this.strokeWidth = strokeWidth;
}
@Override
public float getStrokeWidth() {
return strokeWidth;
}
// -------------------------------
// layout params
// -------------------------------
@Override
protected LayoutParams generateDefaultLayoutParams() {
return new LayoutParams(super.generateDefaultLayoutParams());
}
@Override
public LayoutParams generateLayoutParams(AttributeSet attrs) {
return new LayoutParams(getContext(), attrs);
}
@Override
protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
return new LayoutParams(p);
}
private void layoutAnchoredViews() {
for (int i = 0; i < getChildCount(); i++) {
View child = getChildAt(i);
if (child.getVisibility() != GONE) {
LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (lp.anchorView != 0) {
View anchorView = findViewById(lp.anchorView);
if (anchorView != null && anchorView != child) {
int left = child.getLeft();
int right = child.getRight();
int top = child.getTop();
int bottom = child.getBottom();
if ((lp.anchorGravity & Gravity.BOTTOM) == Gravity.BOTTOM) {
top = anchorView.getBottom() - lp.height / 2;
bottom = top + lp.height;
}
if ((lp.anchorGravity & Gravity.TOP) == Gravity.TOP) {
top = anchorView.getTop() - lp.height / 2;
bottom = top + lp.height;
}
if ((GravityCompat.getAbsoluteGravity(lp.anchorGravity, ViewCompat.getLayoutDirection(child)) & Gravity.LEFT) == Gravity.LEFT) {
left = anchorView.getLeft() - lp.width / 2;
right = left + lp.width;
}
if ((GravityCompat.getAbsoluteGravity(lp.anchorGravity, ViewCompat.getLayoutDirection(child)) & Gravity.RIGHT) == Gravity.RIGHT) {
left = anchorView.getRight() - lp.width / 2;
right = left + lp.width;
}
child.layout(left, top, right, bottom);
}
}
}
}
}
public static class LayoutParams extends android.widget.FrameLayout.LayoutParams {
private int anchorView;
private int anchorGravity;
public LayoutParams(Context c, AttributeSet attrs) {
super(c, attrs);
if (gravity <= 0)
gravity = GravityCompat.START | Gravity.TOP;
TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.FrameLayout_Layout);
anchorView = a.getResourceId(R.styleable.FrameLayout_Layout_carbon_layout_anchor, -1);
anchorGravity = a.getInt(R.styleable.FrameLayout_Layout_carbon_layout_anchorGravity, -1);
if (a.hasValue(R.styleable.FrameLayout_Layout_carbon_layout_marginHorizontal))
leftMargin = rightMargin = a.getDimensionPixelSize(R.styleable.FrameLayout_Layout_carbon_layout_marginHorizontal, 0);
if (a.hasValue(R.styleable.FrameLayout_Layout_carbon_layout_marginVertical))
topMargin = bottomMargin = a.getDimensionPixelSize(R.styleable.FrameLayout_Layout_carbon_layout_marginVertical, 0);
a.recycle();
}
public LayoutParams(int w, int h) {
super(w, h);
if (gravity <= 0)
gravity = GravityCompat.START | Gravity.TOP;
}
/**
* {@inheritDoc}
*/
public LayoutParams(ViewGroup.LayoutParams source) {
super(source);
if (gravity == 0)
gravity = GravityCompat.START | Gravity.TOP;
}
/**
* {@inheritDoc}
*/
public LayoutParams(ViewGroup.MarginLayoutParams source) {
super(source);
if (gravity == 0)
gravity = GravityCompat.START | Gravity.TOP;
}
public LayoutParams(android.widget.FrameLayout.LayoutParams source) {
super((MarginLayoutParams) source);
if (gravity == 0)
gravity = GravityCompat.START | Gravity.TOP;
}
public LayoutParams(LayoutParams source) {
super((MarginLayoutParams) source);
this.anchorView = source.anchorView;
this.anchorGravity = source.anchorGravity;
}
public int getAnchorGravity() {
return anchorGravity;
}
public void setAnchorGravity(int anchorGravity) {
this.anchorGravity = anchorGravity;
}
public int getAnchorView() {
return anchorView;
}
public void setAnchorView(int anchorView) {
this.anchorView = anchorView;
}
}
// -------------------------------
// maximum width & height
// -------------------------------
int maxWidth = Integer.MAX_VALUE, maxHeight = Integer.MAX_VALUE;
@Override
public int getMaxWidth() {
return maxWidth;
}
@Override
public void setMaxWidth(int maxWidth) {
this.maxWidth = maxWidth;
requestLayout();
}
@Override
public int getMaxHeight() {
return maxHeight;
}
@Override
public void setMaxHeight(int maxHeight) {
this.maxHeight = maxHeight;
requestLayout();
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
if (getMeasuredWidth() > maxWidth || getMeasuredHeight() > maxHeight) {
if (getMeasuredWidth() > maxWidth)
widthMeasureSpec = MeasureSpec.makeMeasureSpec(maxWidth, MeasureSpec.EXACTLY);
if (getMeasuredHeight() > maxHeight)
heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY);
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
if (getMeasuredHeight() > maxHeight) {
if (getMeasuredHeight() > maxHeight)
heightMeasureSpec = MeasureSpec.makeMeasureSpec(maxHeight, MeasureSpec.EXACTLY);
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
}
// -------------------------------
// transformations
// -------------------------------
List<OnTransformationChangedListener> transformationChangedListeners = new ArrayList<>();
public void addOnTransformationChangedListener(OnTransformationChangedListener listener) {
transformationChangedListeners.add(listener);
}
public void removeOnTransformationChangedListener(OnTransformationChangedListener listener) {
transformationChangedListeners.remove(listener);
}
public void clearOnTransformationChangedListeners() {
transformationChangedListeners.clear();
}
private void fireOnTransformationChangedListener() {
if (transformationChangedListeners == null)
return;
for (OnTransformationChangedListener listener : transformationChangedListeners)
listener.onTransformationChanged();
}
@Override
public void setRotation(float rotation) {
super.setRotation(rotation);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setRotationY(float rotationY) {
super.setRotationY(rotationY);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setRotationX(float rotationX) {
super.setRotationX(rotationX);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setScaleX(float scaleX) {
super.setScaleX(scaleX);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setScaleY(float scaleY) {
super.setScaleY(scaleY);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setPivotX(float pivotX) {
super.setPivotX(pivotX);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setPivotY(float pivotY) {
super.setPivotY(pivotY);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setAlpha(@FloatRange(from = 0.0, to = 1.0) float alpha) {
super.setAlpha(alpha);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setTranslationX(float translationX) {
super.setTranslationX(translationX);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
@Override
public void setTranslationY(float translationY) {
super.setTranslationY(translationY);
invalidateParentIfNeeded();
fireOnTransformationChangedListener();
}
public void setWidth(int width) {
ViewGroup.LayoutParams layoutParams = getLayoutParams();
if (layoutParams == null) {
setLayoutParams(new ViewGroup.LayoutParams(width, ViewGroup.LayoutParams.WRAP_CONTENT));
} else {
layoutParams.width = width;
setLayoutParams(layoutParams);
}
}
public void setHeight(int height) {
ViewGroup.LayoutParams layoutParams = getLayoutParams();
if (layoutParams == null) {
setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, height));
} else {
layoutParams.height = height;
setLayoutParams(layoutParams);
}
}
public void setSize(int width, int height) {
ViewGroup.LayoutParams layoutParams = getLayoutParams();
if (layoutParams == null) {
setLayoutParams(new ViewGroup.LayoutParams(width, height));
} else {
layoutParams.width = width;
layoutParams.height = height;
setLayoutParams(layoutParams);
}
}
public void setBounds(int x, int y, int width, int height) {
setSize(width, height);
setTranslationX(x);
setTranslationY(y);
}
// -------------------------------
// dependency
// -------------------------------
private List<Behavior> behaviors = new ArrayList<>();
@Override
public void addBehavior(@NotNull Behavior behavior) {
behaviors.add(behavior);
}
@Override
public void removeBehavior(@NotNull Behavior behavior) {
behaviors.remove(behavior);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
Stream.of(behaviors).forEach(Behavior::onDetachedFromWindow);
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
Stream.of(behaviors).forEach(Behavior::onAttachedToWindow);
}
}
