| Methods Summary |
|---|
| public void | applyTheme(android.content.res.Resources.Theme t)Applies the specified theme to this Drawable and its children.
|
| public boolean | canApplyTheme()
return false;
|
| public void | clearColorFilter()Removes the color filter for this drawable.
setColorFilter(null);
|
| public void | clearMutated()Clears the mutated state, allowing this drawable to be cached and
mutated again.
This is hidden because only framework drawables can be cached, so
custom drawables don't need to support constant state, mutate(), or
clearMutated().
// Default implementation is no-op.
|
| public final void | copyBounds(android.graphics.Rect bounds)Return a copy of the drawable's bounds in the specified Rect (allocated
by the caller). The bounds specify where this will draw when its draw()
method is called.
bounds.set(mBounds);
|
| public final android.graphics.Rect | copyBounds()Return a copy of the drawable's bounds in a new Rect. This returns the
same values as getBounds(), but the returned object is guaranteed to not
be changed later by the drawable (i.e. it retains no reference to this
rect). If the caller already has a Rect allocated, call copyBounds(rect).
return new Rect(mBounds);
|
| public static android.graphics.drawable.Drawable | createFromPath(java.lang.String pathName)Create a drawable from file path name.
if (pathName == null) {
return null;
}
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, pathName);
try {
Bitmap bm = BitmapFactory.decodeFile(pathName);
if (bm != null) {
return drawableFromBitmap(null, bm, null, null, null, pathName);
}
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
return null;
|
| public static android.graphics.drawable.Drawable | createFromResourceStream(android.content.res.Resources res, android.util.TypedValue value, java.io.InputStream is, java.lang.String srcName)Create a drawable from an inputstream, using the given resources and
value to determine density information.
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, srcName != null ? srcName : "Unknown drawable");
try {
return createFromResourceStream(res, value, is, srcName, null);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
|
| public static android.graphics.drawable.Drawable | createFromResourceStream(android.content.res.Resources res, android.util.TypedValue value, java.io.InputStream is, java.lang.String srcName, BitmapFactory.Options opts)Create a drawable from an inputstream, using the given resources and
value to determine density information.
if (is == null) {
return null;
}
/* ugh. The decodeStream contract is that we have already allocated
the pad rect, but if the bitmap does not had a ninepatch chunk,
then the pad will be ignored. If we could change this to lazily
alloc/assign the rect, we could avoid the GC churn of making new
Rects only to drop them on the floor.
*/
Rect pad = new Rect();
// Special stuff for compatibility mode: if the target density is not
// the same as the display density, but the resource -is- the same as
// the display density, then don't scale it down to the target density.
// This allows us to load the system's density-correct resources into
// an application in compatibility mode, without scaling those down
// to the compatibility density only to have them scaled back up when
// drawn to the screen.
if (opts == null) opts = new BitmapFactory.Options();
opts.inScreenDensity = res != null
? res.getDisplayMetrics().noncompatDensityDpi : DisplayMetrics.DENSITY_DEVICE;
Bitmap bm = BitmapFactory.decodeResourceStream(res, value, is, pad, opts);
if (bm != null) {
byte[] np = bm.getNinePatchChunk();
if (np == null || !NinePatch.isNinePatchChunk(np)) {
np = null;
pad = null;
}
final Rect opticalInsets = new Rect();
bm.getOpticalInsets(opticalInsets);
return drawableFromBitmap(res, bm, np, pad, opticalInsets, srcName);
}
return null;
|
| public static android.graphics.drawable.Drawable | createFromStream(java.io.InputStream is, java.lang.String srcName)Create a drawable from an inputstream
Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, srcName != null ? srcName : "Unknown drawable");
try {
return createFromResourceStream(null, null, is, srcName);
} finally {
Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
}
|
| public static android.graphics.drawable.Drawable | createFromXml(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser)Create a drawable from an XML document. For more information on how to
create resources in XML, see
Drawable Resources.
return createFromXml(r, parser, null);
|
| public static android.graphics.drawable.Drawable | createFromXml(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.content.res.Resources.Theme theme)Create a drawable from an XML document using an optional {@link Theme}.
For more information on how to create resources in XML, see
Drawable Resources.
AttributeSet attrs = Xml.asAttributeSet(parser);
int type;
while ((type=parser.next()) != XmlPullParser.START_TAG &&
type != XmlPullParser.END_DOCUMENT) {
// Empty loop
}
if (type != XmlPullParser.START_TAG) {
throw new XmlPullParserException("No start tag found");
}
Drawable drawable = createFromXmlInner(r, parser, attrs, theme);
if (drawable == null) {
throw new RuntimeException("Unknown initial tag: " + parser.getName());
}
return drawable;
|
| public static android.graphics.drawable.Drawable | createFromXmlInner(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.util.AttributeSet attrs)Create from inside an XML document. Called on a parser positioned at
a tag in an XML document, tries to create a Drawable from that tag.
Returns null if the tag is not a valid drawable.
return createFromXmlInner(r, parser, attrs, null);
|
| public static android.graphics.drawable.Drawable | createFromXmlInner(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.util.AttributeSet attrs, android.content.res.Resources.Theme theme)Create a drawable from inside an XML document using an optional
{@link Theme}. Called on a parser positioned at a tag in an XML
document, tries to create a Drawable from that tag. Returns {@code null}
if the tag is not a valid drawable.
final Drawable drawable;
final String name = parser.getName();
switch (name) {
case "selector":
drawable = new StateListDrawable();
break;
case "animated-selector":
drawable = new AnimatedStateListDrawable();
break;
case "level-list":
drawable = new LevelListDrawable();
break;
case "layer-list":
drawable = new LayerDrawable();
break;
case "transition":
drawable = new TransitionDrawable();
break;
case "ripple":
drawable = new RippleDrawable();
break;
case "color":
drawable = new ColorDrawable();
break;
case "shape":
drawable = new GradientDrawable();
break;
case "vector":
drawable = new VectorDrawable();
break;
case "animated-vector":
drawable = new AnimatedVectorDrawable();
break;
case "scale":
drawable = new ScaleDrawable();
break;
case "clip":
drawable = new ClipDrawable();
break;
case "rotate":
drawable = new RotateDrawable();
break;
case "animated-rotate":
drawable = new AnimatedRotateDrawable();
break;
case "animation-list":
drawable = new AnimationDrawable();
break;
case "inset":
drawable = new InsetDrawable();
break;
case "bitmap":
drawable = new BitmapDrawable(r);
if (r != null) {
((BitmapDrawable) drawable).setTargetDensity(r.getDisplayMetrics());
}
break;
case "nine-patch":
drawable = new NinePatchDrawable();
if (r != null) {
((NinePatchDrawable) drawable).setTargetDensity(r.getDisplayMetrics());
}
break;
default:
throw new XmlPullParserException(parser.getPositionDescription() +
": invalid drawable tag " + name);
}
drawable.inflate(r, parser, attrs, theme);
return drawable;
|
| public abstract void | draw(android.graphics.Canvas canvas)Draw in its bounds (set via setBounds) respecting optional effects such
as alpha (set via setAlpha) and color filter (set via setColorFilter).
|
| private static android.graphics.drawable.Drawable | drawableFromBitmap(android.content.res.Resources res, android.graphics.Bitmap bm, byte[] np, android.graphics.Rect pad, android.graphics.Rect layoutBounds, java.lang.String srcName)
if (np != null) {
return new NinePatchDrawable(res, bm, np, pad, layoutBounds, srcName);
}
return new BitmapDrawable(res, bm);
|
| public int | getAlpha()Gets the current alpha value for the drawable. 0 means fully transparent,
255 means fully opaque. This method is implemented by
Drawable subclasses and the value returned is specific to how that class treats alpha.
The default return value is 255 if the class does not override this method to return a value
specific to its use of alpha.
return 0xFF;
|
| public final android.graphics.Rect | getBounds()Return the drawable's bounds Rect. Note: for efficiency, the returned
object may be the same object stored in the drawable (though this is not
guaranteed), so if a persistent copy of the bounds is needed, call
copyBounds(rect) instead.
You should also not change the object returned by this method as it may
be the same object stored in the drawable.
if (mBounds == ZERO_BOUNDS_RECT) {
mBounds = new Rect();
}
return mBounds;
|
| public android.graphics.drawable.Drawable$Callback | getCallback()Return the current {@link Callback} implementation attached to this
Drawable.
if (mCallback != null) {
return mCallback.get();
}
return null;
|
| public int | getChangingConfigurations()Return a mask of the configuration parameters for which this drawable
may change, requiring that it be re-created. The default implementation
returns whatever was provided through
{@link #setChangingConfigurations(int)} or 0 by default. Subclasses
may extend this to or in the changing configurations of any other
drawables they hold.
return mChangingConfigurations;
|
| public android.graphics.ColorFilter | getColorFilter()Returns the current color filter, or {@code null} if none set.
return null;
|
| public android.graphics.drawable.Drawable$ConstantState | getConstantState()Return a {@link ConstantState} instance that holds the shared state of this Drawable.
return null;
|
| public android.graphics.drawable.Drawable | getCurrent()
return this;
|
| public android.graphics.Rect | getDirtyBounds()Return the drawable's dirty bounds Rect. Note: for efficiency, the
returned object may be the same object stored in the drawable (though
this is not guaranteed).
By default, this returns the full drawable bounds. Custom drawables may
override this method to perform more precise invalidation.
return getBounds();
|
| public void | getHotspotBounds(android.graphics.Rect outRect)
outRect.set(getBounds());
|
| public int | getIntrinsicHeight()Return the intrinsic height of the underlying drawable object. Returns
-1 if it has no intrinsic height, such as with a solid color.
return -1;
|
| public int | getIntrinsicWidth()Return the intrinsic width of the underlying drawable object. Returns
-1 if it has no intrinsic width, such as with a solid color.
return -1;
|
| public int | getLayoutDirection()Returns the resolved layout direction for this Drawable.
return mLayoutDirection;
|
| public final int | getLevel()Retrieve the current level.
return mLevel;
|
| public int | getMinimumHeight()Returns the minimum height suggested by this Drawable. If a View uses this
Drawable as a background, it is suggested that the View use at least this
value for its height. (There will be some scenarios where this will not be
possible.) This value should INCLUDE any padding.
final int intrinsicHeight = getIntrinsicHeight();
return intrinsicHeight > 0 ? intrinsicHeight : 0;
|
| public int | getMinimumWidth()Returns the minimum width suggested by this Drawable. If a View uses this
Drawable as a background, it is suggested that the View use at least this
value for its width. (There will be some scenarios where this will not be
possible.) This value should INCLUDE any padding.
final int intrinsicWidth = getIntrinsicWidth();
return intrinsicWidth > 0 ? intrinsicWidth : 0;
|
| public abstract int | getOpacity()Return the opacity/transparency of this Drawable. The returned value is
one of the abstract format constants in
{@link android.graphics.PixelFormat}:
{@link android.graphics.PixelFormat#UNKNOWN},
{@link android.graphics.PixelFormat#TRANSLUCENT},
{@link android.graphics.PixelFormat#TRANSPARENT}, or
{@link android.graphics.PixelFormat#OPAQUE}.
Generally a Drawable should be as conservative as possible with the
value it returns. For example, if it contains multiple child drawables
and only shows one of them at a time, if only one of the children is
TRANSLUCENT and the others are OPAQUE then TRANSLUCENT should be
returned. You can use the method {@link #resolveOpacity} to perform a
standard reduction of two opacities to the appropriate single output.
Note that the returned value does not take into account a
custom alpha or color filter that has been applied by the client through
the {@link #setAlpha} or {@link #setColorFilter} methods.
|
| public android.graphics.Insets | getOpticalInsets()Return in insets the layout insets suggested by this Drawable for use with alignment
operations during layout.
return Insets.NONE;
|
| public void | getOutline(android.graphics.Outline outline)Called to get the drawable to populate the Outline that defines its drawing area.
This method is called by the default {@link android.view.ViewOutlineProvider} to define
the outline of the View.
The default behavior defines the outline to be the bounding rectangle of 0 alpha.
Subclasses that wish to convey a different shape or alpha value must override this method.
outline.setRect(getBounds());
outline.setAlpha(0);
|
| public boolean | getPadding(android.graphics.Rect padding)Return in padding the insets suggested by this Drawable for placing
content inside the drawable's bounds. Positive values move toward the
center of the Drawable (set Rect.inset).
padding.set(0, 0, 0, 0);
return false;
|
| public int[] | getState()Describes the current state, as a union of primitve states, such as
{@link android.R.attr#state_focused},
{@link android.R.attr#state_selected}, etc.
Some drawables may modify their imagery based on the selected state.
return mStateSet;
|
| public android.graphics.Region | getTransparentRegion()Returns a Region representing the part of the Drawable that is completely
transparent. This can be used to perform drawing operations, identifying
which parts of the target will not change when rendering the Drawable.
The default implementation returns null, indicating no transparent
region; subclasses can optionally override this to return an actual
Region if they want to supply this optimization information, but it is
not required that they do so.
return null;
|
| public void | inflate(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.util.AttributeSet attrs)Inflate this Drawable from an XML resource. Does not apply a theme.
inflate(r, parser, attrs, null);
|
| public void | inflate(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.util.AttributeSet attrs, android.content.res.Resources.Theme theme)Inflate this Drawable from an XML resource optionally styled by a theme.
final TypedArray a;
if (theme != null) {
a = theme.obtainStyledAttributes(
attrs, com.android.internal.R.styleable.Drawable, 0, 0);
} else {
a = r.obtainAttributes(attrs, com.android.internal.R.styleable.Drawable);
}
inflateWithAttributes(r, parser, a, com.android.internal.R.styleable.Drawable_visible);
a.recycle();
|
| void | inflateWithAttributes(android.content.res.Resources r, org.xmlpull.v1.XmlPullParser parser, android.content.res.TypedArray attrs, int visibleAttr)Inflate a Drawable from an XML resource.
mVisible = attrs.getBoolean(visibleAttr, mVisible);
|
| public void | invalidateSelf()Use the current {@link Callback} implementation to have this Drawable
redrawn. Does nothing if there is no Callback attached to the
Drawable.
final Callback callback = getCallback();
if (callback != null) {
callback.invalidateDrawable(this);
}
|
| public boolean | isAutoMirrored()Tells if this Drawable will be automatically mirrored when its layout direction is RTL
right-to-left. See {@link android.util.LayoutDirection}.
return false;
|
| public boolean | isProjected()Whether this drawable requests projection.
return false;
|
| public boolean | isStateful()Indicates whether this drawable will change its appearance based on
state. Clients can use this to determine whether it is necessary to
calculate their state and call setState.
return false;
|
| public final boolean | isVisible()
return mVisible;
|
| public void | jumpToCurrentState()If this Drawable does transition animations between states, ask that
it immediately jump to the current state and skip any active animations.
|
| public android.graphics.drawable.Drawable | mutate()Make this drawable mutable. This operation cannot be reversed. A mutable
drawable is guaranteed to not share its state with any other drawable.
This is especially useful when you need to modify properties of drawables
loaded from resources. By default, all drawables instances loaded from
the same resource share a common state; if you modify the state of one
instance, all the other instances will receive the same modification.
Calling this method on a mutable Drawable will have no effect.
return this;
|
| static android.content.res.TypedArray | obtainAttributes(android.content.res.Resources res, android.content.res.Resources.Theme theme, android.util.AttributeSet set, int[] attrs)Obtains styled attributes from the theme, if available, or unstyled
resources if the theme is null.
if (theme == null) {
return res.obtainAttributes(set, attrs);
}
return theme.obtainStyledAttributes(set, attrs, 0, 0);
|
| protected void | onBoundsChange(android.graphics.Rect bounds)Override this in your subclass to change appearance if you vary based on
the bounds.
|
| protected boolean | onLevelChange(int level)Override this in your subclass to change appearance if you vary based
on level. return false;
|
| protected boolean | onStateChange(int[] state)Override this in your subclass to change appearance if you recognize the
specified state. return false;
|
| public static android.graphics.PorterDuff.Mode | parseTintMode(int value, android.graphics.PorterDuff.Mode defaultMode)Parses a {@link android.graphics.PorterDuff.Mode} from a tintMode
attribute's enum value.
switch (value) {
case 3: return Mode.SRC_OVER;
case 5: return Mode.SRC_IN;
case 9: return Mode.SRC_ATOP;
case 14: return Mode.MULTIPLY;
case 15: return Mode.SCREEN;
case 16: return Mode.ADD;
default: return defaultMode;
}
|
| public static int | resolveOpacity(int op1, int op2)Return the appropriate opacity value for two source opacities. If
either is UNKNOWN, that is returned; else, if either is TRANSLUCENT,
that is returned; else, if either is TRANSPARENT, that is returned;
else, OPAQUE is returned.
This is to help in implementing {@link #getOpacity}.
if (op1 == op2) {
return op1;
}
if (op1 == PixelFormat.UNKNOWN || op2 == PixelFormat.UNKNOWN) {
return PixelFormat.UNKNOWN;
}
if (op1 == PixelFormat.TRANSLUCENT || op2 == PixelFormat.TRANSLUCENT) {
return PixelFormat.TRANSLUCENT;
}
if (op1 == PixelFormat.TRANSPARENT || op2 == PixelFormat.TRANSPARENT) {
return PixelFormat.TRANSPARENT;
}
return PixelFormat.OPAQUE;
|
| public void | scheduleSelf(java.lang.Runnable what, long when)Use the current {@link Callback} implementation to have this Drawable
scheduled. Does nothing if there is no Callback attached to the
Drawable.
final Callback callback = getCallback();
if (callback != null) {
callback.scheduleDrawable(this, what, when);
}
|
| public abstract void | setAlpha(int alpha)Specify an alpha value for the drawable. 0 means fully transparent, and
255 means fully opaque.
|
| public void | setAutoMirrored(boolean mirrored)Set whether this Drawable is automatically mirrored when its layout direction is RTL
(right-to left). See {@link android.util.LayoutDirection}.
|
| public void | setBounds(int left, int top, int right, int bottom)Specify a bounding rectangle for the Drawable. This is where the drawable
will draw when its draw() method is called.
Rect oldBounds = mBounds;
if (oldBounds == ZERO_BOUNDS_RECT) {
oldBounds = mBounds = new Rect();
}
if (oldBounds.left != left || oldBounds.top != top ||
oldBounds.right != right || oldBounds.bottom != bottom) {
if (!oldBounds.isEmpty()) {
// first invalidate the previous bounds
invalidateSelf();
}
mBounds.set(left, top, right, bottom);
onBoundsChange(mBounds);
}
|
| public void | setBounds(android.graphics.Rect bounds)Specify a bounding rectangle for the Drawable. This is where the drawable
will draw when its draw() method is called.
setBounds(bounds.left, bounds.top, bounds.right, bounds.bottom);
|
| public final void | setCallback(android.graphics.drawable.Drawable$Callback cb)Bind a {@link Callback} object to this Drawable. Required for clients
that want to support animated drawables.
mCallback = new WeakReference<Callback>(cb);
|
| public void | setChangingConfigurations(int configs)Set a mask of the configuration parameters for which this drawable
may change, requiring that it be re-created.
mChangingConfigurations = configs;
|
| public abstract void | setColorFilter(android.graphics.ColorFilter cf)Specify an optional color filter for the drawable. Pass {@code null} to
remove any existing color filter.
|
| public void | setColorFilter(int color, android.graphics.PorterDuff.Mode mode)Specify a color and Porter-Duff mode to be the color filter for this
drawable.
setColorFilter(new PorterDuffColorFilter(color, mode));
|
| public void | setDither(boolean dither)Set to true to have the drawable dither its colors when drawn to a device
with fewer than 8-bits per color component. This can improve the look on
those devices, but can also slow down the drawing a little.
|
| public void | setFilterBitmap(boolean filter)Set to true to have the drawable filter its bitmap when scaled or rotated
(for drawables that use bitmaps). If the drawable does not use bitmaps,
this call is ignored. This can improve the look when scaled or rotated,
but also slows down the drawing.
|
| public void | setHotspot(float x, float y)Specifies the hotspot's location within the drawable.
|
| public void | setHotspotBounds(int left, int top, int right, int bottom)Sets the bounds to which the hotspot is constrained, if they should be
different from the drawable bounds.
|
| public void | setLayoutDirection(int layoutDirection)Set the layout direction for this drawable. Should be a resolved direction as the
Drawable as no capacity to do the resolution on his own.
if (getLayoutDirection() != layoutDirection) {
mLayoutDirection = layoutDirection;
}
|
| public final boolean | setLevel(int level)Specify the level for the drawable. This allows a drawable to vary its
imagery based on a continuous controller, for example to show progress
or volume level.
If the new level you are supplying causes the appearance of the
Drawable to change, then it is responsible for calling
{@link #invalidateSelf} in order to have itself redrawn, and
true will be returned from this function.
if (mLevel != level) {
mLevel = level;
return onLevelChange(level);
}
return false;
|
| public boolean | setState(int[] stateSet)Specify a set of states for the drawable. These are use-case specific,
so see the relevant documentation. As an example, the background for
widgets like Button understand the following states:
[{@link android.R.attr#state_focused},
{@link android.R.attr#state_pressed}].
If the new state you are supplying causes the appearance of the
Drawable to change, then it is responsible for calling
{@link #invalidateSelf} in order to have itself redrawn, and
true will be returned from this function.
Note: The Drawable holds a reference on to stateSet
until a new state array is given to it, so you must not modify this
array during that time.
if (!Arrays.equals(mStateSet, stateSet)) {
mStateSet = stateSet;
return onStateChange(stateSet);
}
return false;
|
| public void | setTint(int tint)Specifies a tint for this drawable.
Setting a color filter via {@link #setColorFilter(ColorFilter)} overrides
tint.
setTintList(ColorStateList.valueOf(tint));
|
| public void | setTintList(android.content.res.ColorStateList tint)Specifies a tint for this drawable as a color state list.
Setting a color filter via {@link #setColorFilter(ColorFilter)} overrides
tint.
|
| public void | setTintMode(android.graphics.PorterDuff.Mode tintMode)Specifies a tint blending mode for this drawable.
Setting a color filter via {@link #setColorFilter(ColorFilter)} overrides
tint.
|
| public boolean | setVisible(boolean visible, boolean restart)Set whether this Drawable is visible. This generally does not impact
the Drawable's behavior, but is a hint that can be used by some
Drawables, for example, to decide whether run animations.
boolean changed = mVisible != visible;
if (changed) {
mVisible = visible;
invalidateSelf();
}
return changed;
|
| public void | setXfermode(android.graphics.Xfermode mode)
// Base implementation drops it on the floor for compatibility. Whee!
// TODO: For this to be included in the API proper, all framework drawables need impls.
// For right now only BitmapDrawable has it.
|
| public void | unscheduleSelf(java.lang.Runnable what)Use the current {@link Callback} implementation to have this Drawable
unscheduled. Does nothing if there is no Callback attached to the
Drawable.
final Callback callback = getCallback();
if (callback != null) {
callback.unscheduleDrawable(this, what);
}
|
| android.graphics.PorterDuffColorFilter | updateTintFilter(android.graphics.PorterDuffColorFilter tintFilter, android.content.res.ColorStateList tint, android.graphics.PorterDuff.Mode tintMode)Ensures the tint filter is consistent with the current tint color and
mode.
if (tint == null || tintMode == null) {
return null;
}
final int color = tint.getColorForState(getState(), Color.TRANSPARENT);
if (tintFilter == null) {
return new PorterDuffColorFilter(color, tintMode);
}
tintFilter.setColor(color);
tintFilter.setMode(tintMode);
return tintFilter;
|
