| /* |
| * Copyright (C) 2006 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.graphics.drawable; |
| |
| import org.xmlpull.v1.XmlPullParser; |
| import org.xmlpull.v1.XmlPullParserException; |
| |
| import android.content.res.ColorStateList; |
| import android.content.res.Resources; |
| import android.content.res.TypedArray; |
| import android.content.res.Resources.Theme; |
| import android.graphics.*; |
| import android.graphics.PorterDuff.Mode; |
| import android.view.Gravity; |
| import android.util.AttributeSet; |
| |
| import java.io.IOException; |
| |
| /** |
| * A Drawable that changes the size of another Drawable based on its current |
| * level value. You can control how much the child Drawable changes in width |
| * and height based on the level, as well as a gravity to control where it is |
| * placed in its overall container. Most often used to implement things like |
| * progress bars. |
| * |
| * <p>It can be defined in an XML file with the <code><scale></code> element. For more |
| * information, see the guide to <a |
| * href="{@docRoot}guide/topics/resources/drawable-resource.html">Drawable Resources</a>.</p> |
| * |
| * @attr ref android.R.styleable#ScaleDrawable_scaleWidth |
| * @attr ref android.R.styleable#ScaleDrawable_scaleHeight |
| * @attr ref android.R.styleable#ScaleDrawable_scaleGravity |
| * @attr ref android.R.styleable#ScaleDrawable_drawable |
| */ |
| public class ScaleDrawable extends Drawable implements Drawable.Callback { |
| private ScaleState mScaleState; |
| private boolean mMutated; |
| private final Rect mTmpRect = new Rect(); |
| |
| ScaleDrawable() { |
| this(null, null); |
| } |
| |
| public ScaleDrawable(Drawable drawable, int gravity, float scaleWidth, float scaleHeight) { |
| this(null, null); |
| |
| mScaleState.mDrawable = drawable; |
| mScaleState.mGravity = gravity; |
| mScaleState.mScaleWidth = scaleWidth; |
| mScaleState.mScaleHeight = scaleHeight; |
| |
| if (drawable != null) { |
| drawable.setCallback(this); |
| } |
| } |
| |
| /** |
| * Returns the drawable scaled by this ScaleDrawable. |
| */ |
| public Drawable getDrawable() { |
| return mScaleState.mDrawable; |
| } |
| |
| private static float getPercent(TypedArray a, int name) { |
| String s = a.getString(name); |
| if (s != null) { |
| if (s.endsWith("%")) { |
| String f = s.substring(0, s.length() - 1); |
| return Float.parseFloat(f) / 100.0f; |
| } |
| } |
| return -1; |
| } |
| |
| @Override |
| public void inflate(Resources r, XmlPullParser parser, AttributeSet attrs, Theme theme) |
| throws XmlPullParserException, IOException { |
| super.inflate(r, parser, attrs, theme); |
| |
| int type; |
| |
| TypedArray a = obtainAttributes( |
| r, theme, attrs, com.android.internal.R.styleable.ScaleDrawable); |
| |
| float sw = getPercent(a, com.android.internal.R.styleable.ScaleDrawable_scaleWidth); |
| float sh = getPercent(a, com.android.internal.R.styleable.ScaleDrawable_scaleHeight); |
| int g = a.getInt(com.android.internal.R.styleable.ScaleDrawable_scaleGravity, Gravity.LEFT); |
| boolean min = a.getBoolean( |
| com.android.internal.R.styleable.ScaleDrawable_useIntrinsicSizeAsMinimum, false); |
| Drawable dr = a.getDrawable(com.android.internal.R.styleable.ScaleDrawable_drawable); |
| |
| a.recycle(); |
| |
| final int outerDepth = parser.getDepth(); |
| while ((type = parser.next()) != XmlPullParser.END_DOCUMENT |
| && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { |
| if (type != XmlPullParser.START_TAG) { |
| continue; |
| } |
| dr = Drawable.createFromXmlInner(r, parser, attrs, theme); |
| } |
| |
| if (dr == null) { |
| throw new IllegalArgumentException("No drawable specified for <scale>"); |
| } |
| |
| mScaleState.mDrawable = dr; |
| mScaleState.mScaleWidth = sw; |
| mScaleState.mScaleHeight = sh; |
| mScaleState.mGravity = g; |
| mScaleState.mUseIntrinsicSizeAsMin = min; |
| if (dr != null) { |
| dr.setCallback(this); |
| } |
| } |
| |
| // overrides from Drawable.Callback |
| |
| public void invalidateDrawable(Drawable who) { |
| if (getCallback() != null) { |
| getCallback().invalidateDrawable(this); |
| } |
| } |
| |
| public void scheduleDrawable(Drawable who, Runnable what, long when) { |
| if (getCallback() != null) { |
| getCallback().scheduleDrawable(this, what, when); |
| } |
| } |
| |
| public void unscheduleDrawable(Drawable who, Runnable what) { |
| if (getCallback() != null) { |
| getCallback().unscheduleDrawable(this, what); |
| } |
| } |
| |
| // overrides from Drawable |
| |
| @Override |
| public void draw(Canvas canvas) { |
| if (mScaleState.mDrawable.getLevel() != 0) |
| mScaleState.mDrawable.draw(canvas); |
| } |
| |
| @Override |
| public int getChangingConfigurations() { |
| return super.getChangingConfigurations() |
| | mScaleState.mChangingConfigurations |
| | mScaleState.mDrawable.getChangingConfigurations(); |
| } |
| |
| @Override |
| public boolean getPadding(Rect padding) { |
| // XXX need to adjust padding! |
| return mScaleState.mDrawable.getPadding(padding); |
| } |
| |
| @Override |
| public boolean setVisible(boolean visible, boolean restart) { |
| mScaleState.mDrawable.setVisible(visible, restart); |
| return super.setVisible(visible, restart); |
| } |
| |
| @Override |
| public void setAlpha(int alpha) { |
| mScaleState.mDrawable.setAlpha(alpha); |
| } |
| |
| @Override |
| public int getAlpha() { |
| return mScaleState.mDrawable.getAlpha(); |
| } |
| |
| @Override |
| public void setColorFilter(ColorFilter cf) { |
| mScaleState.mDrawable.setColorFilter(cf); |
| } |
| |
| @Override |
| public void setTintList(ColorStateList tint) { |
| mScaleState.mDrawable.setTintList(tint); |
| } |
| |
| @Override |
| public void setTintMode(Mode tintMode) { |
| mScaleState.mDrawable.setTintMode(tintMode); |
| } |
| |
| @Override |
| public int getOpacity() { |
| return mScaleState.mDrawable.getOpacity(); |
| } |
| |
| @Override |
| public boolean isStateful() { |
| return mScaleState.mDrawable.isStateful(); |
| } |
| |
| @Override |
| protected boolean onStateChange(int[] state) { |
| boolean changed = mScaleState.mDrawable.setState(state); |
| onBoundsChange(getBounds()); |
| return changed; |
| } |
| |
| @Override |
| protected boolean onLevelChange(int level) { |
| mScaleState.mDrawable.setLevel(level); |
| onBoundsChange(getBounds()); |
| invalidateSelf(); |
| return true; |
| } |
| |
| @Override |
| protected void onBoundsChange(Rect bounds) { |
| final Rect r = mTmpRect; |
| final boolean min = mScaleState.mUseIntrinsicSizeAsMin; |
| int level = getLevel(); |
| int w = bounds.width(); |
| if (mScaleState.mScaleWidth > 0) { |
| final int iw = min ? mScaleState.mDrawable.getIntrinsicWidth() : 0; |
| w -= (int) ((w - iw) * (10000 - level) * mScaleState.mScaleWidth / 10000); |
| } |
| int h = bounds.height(); |
| if (mScaleState.mScaleHeight > 0) { |
| final int ih = min ? mScaleState.mDrawable.getIntrinsicHeight() : 0; |
| h -= (int) ((h - ih) * (10000 - level) * mScaleState.mScaleHeight / 10000); |
| } |
| final int layoutDirection = getLayoutDirection(); |
| Gravity.apply(mScaleState.mGravity, w, h, bounds, r, layoutDirection); |
| |
| if (w > 0 && h > 0) { |
| mScaleState.mDrawable.setBounds(r.left, r.top, r.right, r.bottom); |
| } |
| } |
| |
| @Override |
| public int getIntrinsicWidth() { |
| return mScaleState.mDrawable.getIntrinsicWidth(); |
| } |
| |
| @Override |
| public int getIntrinsicHeight() { |
| return mScaleState.mDrawable.getIntrinsicHeight(); |
| } |
| |
| @Override |
| public ConstantState getConstantState() { |
| if (mScaleState.canConstantState()) { |
| mScaleState.mChangingConfigurations = getChangingConfigurations(); |
| return mScaleState; |
| } |
| return null; |
| } |
| |
| @Override |
| public Drawable mutate() { |
| if (!mMutated && super.mutate() == this) { |
| mScaleState.mDrawable.mutate(); |
| mMutated = true; |
| } |
| return this; |
| } |
| |
| final static class ScaleState extends ConstantState { |
| Drawable mDrawable; |
| int mChangingConfigurations; |
| float mScaleWidth; |
| float mScaleHeight; |
| int mGravity; |
| boolean mUseIntrinsicSizeAsMin; |
| |
| private boolean mCheckedConstantState; |
| private boolean mCanConstantState; |
| |
| ScaleState(ScaleState orig, ScaleDrawable owner, Resources res) { |
| if (orig != null) { |
| if (res != null) { |
| mDrawable = orig.mDrawable.getConstantState().newDrawable(res); |
| } else { |
| mDrawable = orig.mDrawable.getConstantState().newDrawable(); |
| } |
| mDrawable.setCallback(owner); |
| mDrawable.setLayoutDirection(orig.mDrawable.getLayoutDirection()); |
| mDrawable.setBounds(orig.mDrawable.getBounds()); |
| mDrawable.setLevel(orig.mDrawable.getLevel()); |
| mScaleWidth = orig.mScaleWidth; |
| mScaleHeight = orig.mScaleHeight; |
| mGravity = orig.mGravity; |
| mUseIntrinsicSizeAsMin = orig.mUseIntrinsicSizeAsMin; |
| mCheckedConstantState = mCanConstantState = true; |
| } |
| } |
| |
| @Override |
| public Drawable newDrawable() { |
| return new ScaleDrawable(this, null); |
| } |
| |
| @Override |
| public Drawable newDrawable(Resources res) { |
| return new ScaleDrawable(this, res); |
| } |
| |
| @Override |
| public int getChangingConfigurations() { |
| return mChangingConfigurations; |
| } |
| |
| boolean canConstantState() { |
| if (!mCheckedConstantState) { |
| mCanConstantState = mDrawable.getConstantState() != null; |
| mCheckedConstantState = true; |
| } |
| |
| return mCanConstantState; |
| } |
| } |
| |
| private ScaleDrawable(ScaleState state, Resources res) { |
| mScaleState = new ScaleState(state, this, res); |
| } |
| } |
| |