Code example for Drawable

Methods: setAlphasetBoundssetColorFiltersetDithersetLevelsetStatesetVisible

0
        final long now = SystemClock.uptimeMillis();
        boolean animating = false;
        if (mCurrDrawable != null) {
            if (mEnterAnimationEnd != 0) {
                if (mEnterAnimationEnd <= now) {
                    mCurrDrawable.setAlpha(mAlpha);
                    mEnterAnimationEnd = 0;
                } else { 
                    int animAlpha = (int) ((mEnterAnimationEnd - now) * 255)
                            / mDrawableContainerState.mEnterFadeDuration;
                    mCurrDrawable.setAlpha((255 - animAlpha) * mAlpha / 255);
                    animating = true;
                } 
            } 
        } else { 
            mEnterAnimationEnd = 0;
        } 
        if (mLastDrawable != null) {
            if (mExitAnimationEnd != 0) {
                if (mExitAnimationEnd <= now) {
                    mLastDrawable.setVisible(false, false);
                    mLastDrawable = null;
                    mExitAnimationEnd = 0;
                } else { 
                    int animAlpha = (int) ((mExitAnimationEnd - now) * 255)
                            / mDrawableContainerState.mExitFadeDuration;
                    mLastDrawable.setAlpha(animAlpha * mAlpha / 255);
                    animating = true;
                } 
            } 
        } else { 
            mExitAnimationEnd = 0;
        } 
        if (schedule && animating) {
            scheduleSelf(mAnimationRunnable, now + 1000 / 60);
        } 
    } 
 
    @Override 
    public void draw(Canvas canvas) {
        if (mCurrDrawable != null) {
            mCurrDrawable.draw(canvas);
        } 
        if (mLastDrawable != null) {
            mLastDrawable.draw(canvas);
        } 
    } 
 
    @Override 
    public int getChangingConfigurations() { 
        return super.getChangingConfigurations() 
                | mDrawableContainerState.mChangingConfigurations
                | mDrawableContainerState.mChildrenChangingConfigurations;
    } 
 
    @Override 
    public ConstantState getConstantState() {
        if (mDrawableContainerState.canConstantState()) {
            mDrawableContainerState.mChangingConfigurations = getChangingConfigurations();
            return mDrawableContainerState;
        } 
        return null; 
    } 
 
    @Override 
    public Drawable getCurrent() {
        return mCurrDrawable;
    } 
 
    @Override 
    public int getIntrinsicHeight() { 
        if (mDrawableContainerState.isConstantSize()) {
            return mDrawableContainerState.getConstantHeight();
        } 
        return mCurrDrawable != null ? mCurrDrawable.getIntrinsicHeight() : -1;
    } 
 
    @Override 
    public int getIntrinsicWidth() { 
        if (mDrawableContainerState.isConstantSize()) {
            return mDrawableContainerState.getConstantWidth();
        } 
        return mCurrDrawable != null ? mCurrDrawable.getIntrinsicWidth() : -1;
    } 
 
    @Override 
    public int getMinimumHeight() { 
        if (mDrawableContainerState.isConstantSize()) {
            return mDrawableContainerState.getConstantMinimumHeight();
        } 
        return mCurrDrawable != null ? mCurrDrawable.getMinimumHeight() : 0;
    } 
 
    @Override 
    public int getMinimumWidth() { 
        if (mDrawableContainerState.isConstantSize()) {
            return mDrawableContainerState.getConstantMinimumWidth();
        } 
        return mCurrDrawable != null ? mCurrDrawable.getMinimumWidth() : 0;
    } 
 
    @Override 
    public int getOpacity() { 
        return mCurrDrawable == null || !mCurrDrawable.isVisible() ? PixelFormat.TRANSPARENT :
                mDrawableContainerState.getOpacity();
    } 
 
    @Override 
    public boolean getPadding(Rect padding) {
        final Rect r = mDrawableContainerState.getConstantPadding();
        if (r != null) {
            padding.set(r);
            return true; 
        } 
        if (mCurrDrawable != null) {
            return mCurrDrawable.getPadding(padding);
        } else { 
            return super.getPadding(padding);
        } 
    } 
 
    @Override 
    public void invalidateDrawable(Drawable who) {
        if (who == mCurrDrawable && getCallback() != null) {
            getCallback().invalidateDrawable(this);
        } 
    } 
 
    @Override 
    public boolean isStateful() { 
        return mDrawableContainerState.isStateful();
    } 
 
    @Override 
    public void jumpToCurrentState() { 
        boolean changed = false;
        if (mLastDrawable != null) {
            mLastDrawable.jumpToCurrentState();
            mLastDrawable = null;
            changed = true;
        } 
        if (mCurrDrawable != null) {
            mCurrDrawable.jumpToCurrentState();
            mCurrDrawable.setAlpha(mAlpha);
        } 
        if (mExitAnimationEnd != 0) {
            mExitAnimationEnd = 0;
            changed = true;
        } 
        if (mEnterAnimationEnd != 0) {
            mEnterAnimationEnd = 0;
            changed = true;
        } 
        if (changed) {
            invalidateSelf();
        } 
    } 
 
    @Override 
    public Drawable mutate() {
        if (!mMutated && super.mutate() == this) {
            final int N = mDrawableContainerState.getChildCount();
            final Drawable[] drawables = mDrawableContainerState.getChildren();
            for (int i = 0; i < N; i++) {
                if (drawables[i] != null) {
                    drawables[i].mutate();
                } 
            } 
            mMutated = true;
        } 
        return this;
    } 
 
    @Override 
    protected void onBoundsChange(Rect bounds) {
        if (mLastDrawable != null) {
            mLastDrawable.setBounds(bounds);
        } 
        if (mCurrDrawable != null) {
            mCurrDrawable.setBounds(bounds);
        } 
    } 
 
    @Override 
    protected boolean onLevelChange(int level) {
        if (mLastDrawable != null) {
            return mLastDrawable.setLevel(level);
        } 
        if (mCurrDrawable != null) {
            return mCurrDrawable.setLevel(level);
        } 
        return false; 
    } 
 
    @Override 
    protected boolean onStateChange(int[] state) {
        if (mLastDrawable != null) {
            return mLastDrawable.setState(state);
        } 
        if (mCurrDrawable != null) {
            return mCurrDrawable.setState(state);
        } 
        return false; 
    } 
 
    @Override 
    public void scheduleDrawable(Drawable who, Runnable what, long when) {
        if (who == mCurrDrawable && getCallback() != null) {
            getCallback().scheduleDrawable(this, what, when);
        } 
    } 
 
    public boolean selectDrawable(int idx) {
        if (idx == mCurIndex) {
            return false; 
        } 
        final long now = SystemClock.uptimeMillis();
        if (mDrawableContainerState.mExitFadeDuration > 0) {
            if (mLastDrawable != null) {
                mLastDrawable.setVisible(false, false);
            } 
            if (mCurrDrawable != null) {
                mLastDrawable = mCurrDrawable;
                mExitAnimationEnd = now + mDrawableContainerState.mExitFadeDuration;
            } else { 
                mLastDrawable = null;
                mExitAnimationEnd = 0;
            } 
        } else if (mCurrDrawable != null) {
            mCurrDrawable.setVisible(false, false);
        } 
 
        if (idx >= 0 && idx < mDrawableContainerState.mNumChildren) {
            Drawable d = mDrawableContainerState.mDrawables[idx];
            mCurrDrawable = d;
            mCurIndex = idx;
            if (d != null) {
                if (mDrawableContainerState.mEnterFadeDuration > 0) {
                    mEnterAnimationEnd = now + mDrawableContainerState.mEnterFadeDuration;
                } else { 
                    d.setAlpha(mAlpha);
                } 
                d.setVisible(isVisible(), true);
                d.setDither(mDrawableContainerState.mDither);
                d.setColorFilter(mColorFilter);
                d.setState(getState());
                d.setLevel(getLevel());
                d.setBounds(getBounds());
            } 
        } else { 
            mCurrDrawable = null;
            mCurIndex = -1;
        }