donut snapshot

10 files changed, 279 insertions, 105 deletions

diff --git a/graphics/java/android/graphics/Bitmap.java b/graphics/java/android/graphics/Bitmap.java
index 0b398bc..fda584d 100644
--- a/graphics/java/android/graphics/Bitmap.java
+++ b/graphics/java/android/graphics/Bitmap.java
@@ -400,7 +400,7 @@ public final class Bitmap implements Parcelable {
      * @param y        The y coordinate of the first pixel in source
      * @param width    The number of pixels in each row
      * @param height   The number of rows
-     * @param m        Option matrix to be applied to the pixels
+     * @param m        Optional matrix to be applied to the pixels
      * @param filter   true if the source should be filtered.
      *                   Only applies if the matrix contains more than just
      *                   translation.
diff --git a/graphics/java/android/graphics/BitmapFactory.java b/graphics/java/android/graphics/BitmapFactory.java
index 3813d8f..9e88d7e 100644
--- a/graphics/java/android/graphics/BitmapFactory.java
+++ b/graphics/java/android/graphics/BitmapFactory.java
@@ -103,6 +103,36 @@ public class BitmapFactory {
         public boolean inScaled;
 
         /**
+         * If this is set to true, then the resulting bitmap will allocate its
+         * pixels such that they can be purged if the system needs to reclaim
+         * memory. In that instance, when the pixels need to be accessed again
+         * (e.g. the bitmap is drawn, getPixels() is called), they will be
+         * automatically re-decoded.
+         *
+         * For the re-decode to happen, the bitmap must have access to the
+         * encoded data, either by sharing a reference to the input
+         * or by making a copy of it. This distinction is controlled by
+         * inInputShareable. If this is true, then the bitmap may keep a shallow
+         * reference to the input. If this is false, then the bitmap will
+         * explicitly make a copy of the input data, and keep that. Even if
+         * sharing is allowed, the implementation may still decide to make a
+         * deep copy of the input data.
+         *
+         * @hide pending API council approval
+         */
+        public boolean inPurgeable;
+
+        /**
+         * This field works in conjuction with inPurgeable. If inPurgeable is
+         * false, then this field is ignored. If inPurgeable is true, then this
+         * field determines whether the bitmap can share a reference to the
+         * input data (inputstream, array, etc.) or if it must make a deep copy.
+         *
+         * @hide pending API council approval
+         */
+        public boolean inInputShareable;
+
+        /**
          * The resulting width of the bitmap, set independent of the state of
          * inJustDecodeBounds. However, if there is an error trying to decode,
          * outWidth will be set to -1.
diff --git a/graphics/java/android/graphics/Canvas.java b/graphics/java/android/graphics/Canvas.java
index 32ecd9f..06d53e3 100644
--- a/graphics/java/android/graphics/Canvas.java
+++ b/graphics/java/android/graphics/Canvas.java
@@ -112,7 +112,9 @@ public class Canvas {
      * on behalf of the Canvas. Any subsequent drawing with a GL-backed Canvas
      * will have to recreate those resources.
      */
-    public static native void freeGlCaches();
+    public static void freeGlCaches() {
+        freeCaches();
+    }
         
     /**
      * Specify a bitmap for the canvas to draw into.
@@ -1405,6 +1407,14 @@ public class Canvas {
         finalizer(mNativeCanvas);
     }
 
+    /**
+     * Free up as much memory as possible from private caches (e.g. fonts,
+     * images)
+     *
+     * @hide - for now
+     */
+    public static native void freeCaches();
+
     private static native int initRaster(int nativeBitmapOrZero);
     private static native int initGL();
     private static native void native_setBitmap(int nativeCanvas, int bitmap);
diff --git a/graphics/java/android/graphics/Matrix.java b/graphics/java/android/graphics/Matrix.java
index 2681eae..f549900 100644
--- a/graphics/java/android/graphics/Matrix.java
+++ b/graphics/java/android/graphics/Matrix.java
@@ -16,6 +16,8 @@
 
 package android.graphics;
 
+import java.io.PrintWriter;
+
 
 /**
  * The Matrix class holds a 3x3 matrix for transforming coordinates.
@@ -539,17 +541,49 @@ public class Matrix {
     }
 
     public String toString() {
-        return "Matrix{" + toShortString() + "}";
+        StringBuilder sb = new StringBuilder(64);
+        sb.append("Matrix{");
+        toShortString(sb);
+        sb.append('}');
+        return sb.toString();
                 
     }
 
     public String toShortString() {
+        StringBuilder sb = new StringBuilder(64);
+        toShortString(sb);
+        return sb.toString();
+    }
+
+    /**
+     * @hide
+     */
+    public void toShortString(StringBuilder sb) {
+        float[] values = new float[9];
+        getValues(values);
+        sb.append('[');
+        sb.append(values[0]); sb.append(", "); sb.append(values[1]); sb.append(", ");
+        sb.append(values[2]); sb.append("][");
+        sb.append(values[3]); sb.append(", "); sb.append(values[4]); sb.append(", ");
+        sb.append(values[5]); sb.append("][");
+        sb.append(values[6]); sb.append(", "); sb.append(values[7]); sb.append(", ");
+        sb.append(values[8]); sb.append(']');
+    }
+
+    /**
+     * Print short string, to optimize dumping.
+     * @hide
+     */
+    public void printShortString(PrintWriter pw) {
         float[] values = new float[9];
         getValues(values);
-        return "[" +
-                values[0] + ", " + values[1] + ", " + values[2] + "][" +
-                values[3] + ", " + values[4] + ", " + values[5] + "][" +
-                values[6] + ", " + values[7] + ", " + values[8] + "]";
+        pw.print('[');
+        pw.print(values[0]); pw.print(", "); pw.print(values[1]); pw.print(", ");
+                pw.print(values[2]); pw.print("][");
+        pw.print(values[3]); pw.print(", "); pw.print(values[4]); pw.print(", ");
+                pw.print(values[5]); pw.print("][");
+        pw.print(values[6]); pw.print(", "); pw.print(values[7]); pw.print(", ");
+                pw.print(values[8]); pw.print(']');
                 
     }
 
diff --git a/graphics/java/android/graphics/Paint.java b/graphics/java/android/graphics/Paint.java
index 81980d9..862e827 100644
--- a/graphics/java/android/graphics/Paint.java
+++ b/graphics/java/android/graphics/Paint.java
@@ -1084,8 +1084,9 @@ public class Paint {
      * not null, return in it the actual width measured.
      *
      * @param text  The text to measure
-     * @param measureForwards If true, measure forwards, starting at index.
-     *                        Otherwise, measure backwards, starting with the
+     * @param measureForwards If true, measure forwards, starting with the
+     *                        first character in the string. Otherwise,
+     *                        measure backwards, starting with the
      *                        last character in the string.
      * @param maxWidth The maximum width to accumulate.
      * @param measuredWidth Optional. If not null, returns the actual width
diff --git a/graphics/java/android/graphics/Rect.java b/graphics/java/android/graphics/Rect.java
index 2005344..50ab566 100644
--- a/graphics/java/android/graphics/Rect.java
+++ b/graphics/java/android/graphics/Rect.java
@@ -19,6 +19,8 @@ package android.graphics;
 import android.os.Parcel;
 import android.os.Parcelable;
 
+import java.io.PrintWriter;
+
 /**
  * Rect holds four integer coordinates for a rectangle. The rectangle is
  * represented by the coordinates of its 4 edges (left, top, right bottom).
@@ -78,14 +80,40 @@ public final class Rect implements Parcelable {
     }
 
     public String toString() {
-        return "Rect(" + left + ", " + top + " - " + right + ", " + bottom + ")";
+        StringBuilder sb = new StringBuilder(32);
+        sb.append("Rect("); sb.append(left); sb.append(", ");
+        sb.append(top); sb.append(" - "); sb.append(right);
+        sb.append(", "); sb.append(bottom); sb.append(")");
+        return sb.toString();
     }
 
     /**
      * Return a string representation of the rectangle in a compact form.
      */
     public String toShortString() {
-        return "[" + left + "," + top + "][" + right + "," + bottom + "]";
+        return toShortString(new StringBuilder(32));
+    }
+    
+    /**
+     * Return a string representation of the rectangle in a compact form.
+     * @hide
+     */
+    public String toShortString(StringBuilder sb) {
+        sb.setLength(0);
+        sb.append('['); sb.append(left); sb.append(',');
+        sb.append(top); sb.append("]["); sb.append(right);
+        sb.append(','); sb.append(bottom); sb.append(']');
+        return sb.toString();
+    }
+    
+    /**
+     * Print short representation to given writer.
+     * @hide
+     */
+    public void printShortString(PrintWriter pw) {
+        pw.print('['); pw.print(left); pw.print(',');
+        pw.print(top); pw.print("]["); pw.print(right);
+        pw.print(','); pw.print(bottom); pw.print(']');
     }
     
     /**
@@ -517,4 +545,17 @@ public final class Rect implements Parcelable {
         right = in.readInt();
         bottom = in.readInt();
     }
+
+    /**
+     * Scales up the rect by the given scale.
+     * @hide
+     */
+    public void scale(float scale) {
+        if (scale != 1.0f) {
+            left *= scale;
+            top *= scale;
+            right *= scale;
+            bottom*= scale;
+        }
+    }
 }
diff --git a/graphics/java/android/graphics/Region.java b/graphics/java/android/graphics/Region.java
index 544ff4f..2b080aa 100644
--- a/graphics/java/android/graphics/Region.java
+++ b/graphics/java/android/graphics/Region.java
@@ -211,6 +211,26 @@ public class Region implements Parcelable {
      */
     public native void translate(int dx, int dy, Region dst);
 
+    /**
+     * Scale the region by the given scale amount. This re-constructs new region by
+     * scaling the rects that this region consists of. New rectis are computed by scaling 
+     * coordinates by float, then rounded by roundf() function to integers. This may results
+     * in less internal rects if 0 < scale < 1. Zero and Negative scale result in
+     * an empty region. If this region is empty, do nothing.
+     *
+     * @hide
+     */
+    public void scale(float scale) {
+        scale(scale, null);
+    }
+
+    /**
+     * Set the dst region to the result of scaling this region by the given scale amount.
+     * If this region is empty, then dst will be set to empty.
+     * @hide
+     */
+    public native void scale(float scale, Region dst);
+
     public final boolean union(Rect r) {
         return op(r, Op.UNION);
     }
@@ -294,7 +314,16 @@ public class Region implements Parcelable {
             throw new RuntimeException();
         }
     }
-    
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null || !(obj instanceof Region)) {
+            return false;
+        }
+        Region peer = (Region) obj;
+        return nativeEquals(mNativeRegion, peer.mNativeRegion);
+    }
+
     protected void finalize() throws Throwable {
         nativeDestructor(mNativeRegion);
     }
@@ -340,5 +369,7 @@ public class Region implements Parcelable {
     private static native boolean nativeWriteToParcel(int native_region,
                                                       Parcel p);
 
+    private static native boolean nativeEquals(int native_r1, int native_r2);
+
     private final int mNativeRegion;
 }
diff --git a/graphics/java/android/graphics/Typeface.java b/graphics/java/android/graphics/Typeface.java
index c69c92c..e40e84a 100644
--- a/graphics/java/android/graphics/Typeface.java
+++ b/graphics/java/android/graphics/Typeface.java
@@ -18,6 +18,8 @@ package android.graphics;
 
 import android.content.res.AssetManager;
 
+import java.io.File;
+
 /**
  * The Typeface class specifies the typeface and intrinsic style of a font.
  * This is used in the paint, along with optionally Paint settings like
@@ -118,7 +120,27 @@ public class Typeface {
     public static Typeface createFromAsset(AssetManager mgr, String path) {
         return new Typeface(nativeCreateFromAsset(mgr, path));
     }
-    
+
+    /**
+     * Create a new typeface from the specified font file.
+     *
+     * @param path The path to the font data. 
+     * @return The new typeface.
+     */
+    public static Typeface createFromFile(File path) {
+        return new Typeface(nativeCreateFromFile(path.getAbsolutePath()));
+    }
+
+    /**
+     * Create a new typeface from the specified font file.
+     *
+     * @param path The full path to the font data. 
+     * @return The new typeface.
+     */
+    public static Typeface createFromFile(String path) {
+        return new Typeface(nativeCreateFromFile(path));
+    }
+
     // don't allow clients to call this directly
     private Typeface(int ni) {
         native_instance = ni;
@@ -140,14 +162,14 @@ public class Typeface {
     }
 
     protected void finalize() throws Throwable {
+        super.finalize();
         nativeUnref(native_instance);
     }
 
     private static native int  nativeCreate(String familyName, int style);
-    private static native int  nativeCreateFromTypeface(int native_instance,
-                                                        int style);
+    private static native int  nativeCreateFromTypeface(int native_instance, int style); 
     private static native void nativeUnref(int native_instance);
     private static native int  nativeGetStyle(int native_instance);
-    private static native int  nativeCreateFromAsset(AssetManager mgr,
-                                                     String path);
+    private static native int  nativeCreateFromAsset(AssetManager mgr, String path);
+    private static native int nativeCreateFromFile(String path);
 }
diff --git a/graphics/java/android/graphics/drawable/Drawable.java b/graphics/java/android/graphics/drawable/Drawable.java
index 42e28e8..f0d49f5 100644
--- a/graphics/java/android/graphics/drawable/Drawable.java
+++ b/graphics/java/android/graphics/drawable/Drawable.java
@@ -38,32 +38,32 @@ import android.util.TypedValue;
  * dealing with an underlying visual resource that may take a variety of forms.
  * Unlike a {@link android.view.View}, a Drawable does not have any facility to
  * receive events or otherwise interact with the user.
- * 
+ *
  * <p>In addition to simple drawing, Drawable provides a number of generic
  * mechanisms for its client to interact with what is being drawn:
- * 
+ *
  * <ul>
  *     <li> The {@link #setBounds} method <var>must</var> be called to tell the
  *     Drawable where it is drawn and how large it should be.  All Drawables
  *     should respect the requested size, often simply by scaling their
  *     imagery.  A client can find the preferred size for some Drawables with
  *     the {@link #getIntrinsicHeight} and {@link #getIntrinsicWidth} methods.
- * 
+ *
  *     <li> The {@link #getPadding} method can return from some Drawables
  *     information about how to frame content that is placed inside of them.
  *     For example, a Drawable that is intended to be the frame for a button
  *     widget would need to return padding that correctly places the label
  *     inside of itself.
- * 
+ *
  *     <li> The {@link #setState} method allows the client to tell the Drawable
  *     in which state it is to be drawn, such as "focused", "selected", etc.
  *     Some drawables may modify their imagery based on the selected state.
- * 
+ *
  *     <li> The {@link #setLevel} method allows the client to supply a single
  *     continuous controller that can modify the Drawable is displayed, such as
  *     a battery level or progress level.  Some drawables may modify their
  *     imagery based on the current level.
- * 
+ *
  *     <li> A Drawable can perform animations by calling back to its client
  *     through the {@link Callback} interface.  All clients should support this
  *     interface (via {@link #setCallback}) so that animations will work.  A
@@ -71,7 +71,7 @@ import android.util.TypedValue;
  *     {@link android.view.View#setBackgroundDrawable(Drawable)} and
  *     {@link android.widget.ImageView}.
  * </ul>
- * 
+ *
  * Though usually not visible to the application, Drawables may take a variety
  * of forms:
  *
@@ -96,11 +96,12 @@ import android.util.TypedValue;
  * and Internationalization</a>.
  */
 public abstract class Drawable {
+    private static final Rect ZERO_BOUNDS_RECT = new Rect();
 
     private int[] mStateSet = StateSet.WILD_CARD;
     private int mLevel = 0;
     private int mChangingConfigurations = 0;
-    private Rect mBounds = new Rect();
+    private Rect mBounds = ZERO_BOUNDS_RECT;
     /*package*/ Callback mCallback = null;
     private boolean mVisible = true;
 
@@ -118,14 +119,18 @@ public abstract class Drawable {
      */
     public void setBounds(int left, int top, int right, int bottom) {
         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) {
             mBounds.set(left, top, right, bottom);
             onBoundsChange(mBounds);
         }
     }
-    
+
     /**
      * Specify a bounding rectangle for the Drawable. This is where the drawable
      * will draw when its draw() method is called.
@@ -145,12 +150,12 @@ public abstract class Drawable {
     public final void copyBounds(Rect bounds) {
         bounds.set(mBounds);
     }
-    
+
     /**
      * 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)
+     * rect). If the caller already has a Rect allocated, call copyBounds(rect).
      *
      * @return A copy of the drawable's bounds
      */
@@ -163,27 +168,37 @@ public abstract class Drawable {
      * 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.
      *
      * @return The bounds of the drawable (which may change later, so caller
-     *         beware).
+     *         beware). DO NOT ALTER the returned object as it may change the
+     *         stored bounds of this drawable.
+     *
+     * @see #copyBounds()
+     * @see #copyBounds(android.graphics.Rect) 
      */
     public final Rect getBounds() {
+        if (mBounds == ZERO_BOUNDS_RECT) {
+            mBounds = new Rect();
+        }
+
         return mBounds;
     }
 
     /**
      * Set a mask of the configuration parameters for which this drawable
      * may change, requiring that it be re-created.
-     * 
+     *
      * @param configs A mask of the changing configuration parameters, as
      * defined by {@link android.content.res.Configuration}.
-     * 
+     *
      * @see android.content.res.Configuration
      */
     public void setChangingConfigurations(int configs) {
         mChangingConfigurations = configs;
     }
-    
+
     /**
      * Return a mask of the configuration parameters for which this drawable
      * mau change, requiring that it be re-created.  The default implementation
@@ -191,23 +206,23 @@ public abstract class Drawable {
      * {@link #setChangingConfigurations(int)} or 0 by default.  Subclasses
      * may extend this to or in the changing configurations of any other
      * drawables they hold.
-     * 
+     *
      * @return Returns a mask of the changing configuration parameters, as
      * defined by {@link android.content.res.Configuration}.
-     * 
+     *
      * @see android.content.res.Configuration
      */
     public int getChangingConfigurations() {
         return mChangingConfigurations;
     }
-    
+
     /**
      * 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 setDither(boolean dither) {}
-    
+
     /**
      * 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,
@@ -229,7 +244,7 @@ public abstract class Drawable {
          * Called when the drawable needs to be redrawn.  A view at this point
          * should invalidate itself (or at least the part of itself where the
          * drawable appears).
-         * 
+         *
          * @param who The drawable that is requesting the update.
          */
         public void invalidateDrawable(Drawable who);
@@ -240,7 +255,7 @@ public abstract class Drawable {
          * {@link android.os.Handler#postAtTime(Runnable, Object, long)} with
          * the parameters <var>(what, who, when)</var> to perform the
          * scheduling.
-         * 
+         *
          * @param who The drawable being scheduled.
          * @param what The action to execute.
          * @param when The time (in milliseconds) to run.  The timebase is
@@ -254,7 +269,7 @@ public abstract class Drawable {
          * generally simply call
          * {@link android.os.Handler#removeCallbacks(Runnable, Object)} with
          * the parameters <var>(what, who)</var> to unschedule the drawable.
-         * 
+         *
          * @param who The drawable being unscheduled.
          * @param what The action being unscheduled.
          */
@@ -264,7 +279,7 @@ public abstract class Drawable {
     /**
      * Bind a {@link Callback} object to this Drawable.  Required for clients
      * that want to support animated drawables.
-     * 
+     *
      * @param cb The client's Callback implementation.
      */
     public final void setCallback(Callback cb) {
@@ -275,7 +290,7 @@ public abstract class Drawable {
      * Use the current {@link Callback} implementation to have this Drawable
      * redrawn.  Does nothing if there is no Callback attached to the
      * Drawable.
-     * 
+     *
      * @see Callback#invalidateDrawable
      */
     public void invalidateSelf()
@@ -289,10 +304,10 @@ public abstract class Drawable {
      * Use the current {@link Callback} implementation to have this Drawable
      * scheduled.  Does nothing if there is no Callback attached to the
      * Drawable.
-     * 
+     *
      * @param what The action being scheduled.
      * @param when The time (in milliseconds) to run.
-     * 
+     *
      * @see Callback#scheduleDrawable
      */
     public void scheduleSelf(Runnable what, long when)
@@ -306,9 +321,9 @@ public abstract class Drawable {
      * Use the current {@link Callback} implementation to have this Drawable
      * unscheduled.  Does nothing if there is no Callback attached to the
      * Drawable.
-     * 
+     *
      * @param what The runnable that you no longer want called.
-     * 
+     *
      * @see Callback#unscheduleDrawable
      */
     public void unscheduleSelf(Runnable what)
@@ -323,13 +338,13 @@ public abstract class Drawable {
      * 255 means fully opaque.
      */
     public abstract void setAlpha(int alpha);
-    
+
     /**
      * Specify an optional colorFilter for the drawable. Pass null to remove
      * any filters.
     */
     public abstract void setColorFilter(ColorFilter cf);
-    
+
     /**
      * Specify a color and porterduff mode to be the colorfilter for this
      * drawable.
@@ -337,7 +352,7 @@ public abstract class Drawable {
     public void setColorFilter(int color, PorterDuff.Mode mode) {
         setColorFilter(new PorterDuffColorFilter(color, mode));
     }
-    
+
     public void clearColorFilter() {
         setColorFilter(null);
     }
@@ -346,34 +361,34 @@ public abstract class Drawable {
      * Indicates whether this view 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 True if this view changes its appearance based on state, false
      *         otherwise.
-     * 
+     *
      * @see #setState(int[])
      */
     public boolean isStateful() {
         return false;
     }
-    
+
     /**
      * 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}].
-     * 
+     *
      * <p>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, <em>and</em>
      * true will be returned from this function.
-     * 
+     *
      * <p>Note: The Drawable holds a reference on to <var>stateSet</var>
      * until a new state array is given to it, so you must not modify this
      * array during that time.</p>
-     * 
+     *
      * @param stateSet The new set of states to be displayed.
-     * 
+     *
      * @return Returns true if this change in state has caused the appearance
      * of the Drawable to change (hence requiring an invalidate), otherwise
      * returns false.
@@ -396,7 +411,7 @@ public abstract class Drawable {
     public int[] getState() {
         return mStateSet;
     }
-    
+
     /**
      * @return The current drawable that will be used by this drawable. For simple drawables, this
      *         is just the drawable itself. For drawables that change state like
@@ -416,9 +431,9 @@ public abstract class Drawable {
      * Drawable to change, then it is responsible for calling
      * {@link #invalidateSelf} in order to have itself redrawn, <em>and</em>
      * true will be returned from this function.
-     * 
+     *
      * @param level The new level, from 0 (minimum) to 10000 (maximum).
-     * 
+     *
      * @return Returns true if this change in level has caused the appearance
      * of the Drawable to change (hence requiring an invalidate), otherwise
      * returns false.
@@ -529,7 +544,7 @@ public abstract class Drawable {
      * 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 Returns null if the Drawables has no transparent region to
      * report, else a Region holding the parts of the Drawable's bounds that
      * are transparent.
@@ -537,11 +552,11 @@ public abstract class Drawable {
     public Region getTransparentRegion() {
         return null;
     }
-    
+
     /**
      * Override this in your subclass to change appearance if you recognize the
      * specified state.
-     * 
+     *
      * @return Returns true if the state change has caused the appearance of
      * the Drawable to change (that is, it needs to be drawn), else false
      * if it looks the same and there is no need to redraw it since its
@@ -577,13 +592,13 @@ public abstract class Drawable {
     public int getIntrinsicHeight() {
         return -1;
     }
-    
+
     /**
      * 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.
-     * 
+     *
      * @return The minimum width suggested by this Drawable. If this Drawable
      *         doesn't have a suggested minimum width, 0 is returned.
      */
@@ -597,7 +612,7 @@ public abstract class Drawable {
      * 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.
-     * 
+     *
      * @return The minimum height suggested by this Drawable. If this Drawable
      *         doesn't have a suggested minimum height, 0 is returned.
      */
@@ -605,7 +620,7 @@ public abstract class Drawable {
         final int intrinsicHeight = getIntrinsicHeight();
         return intrinsicHeight > 0 ? intrinsicHeight : 0;
     }
-    
+
     /**
      * Return in padding the insets suggested by this Drawable for placing
      * content inside the drawable's bounds. Positive values move toward the
@@ -643,7 +658,7 @@ public abstract class Drawable {
 
     /**
      * Create a drawable from an inputstream
-     * 
+     *
      * @hide pending API council approval
      */
     public static Drawable createFromResourceStream(Resources res, TypedValue value,
diff --git a/graphics/java/android/graphics/drawable/DrawableContainer.java b/graphics/java/android/graphics/drawable/DrawableContainer.java
index 29f2a00..f8b88d0 100644
--- a/graphics/java/android/graphics/drawable/DrawableContainer.java
+++ b/graphics/java/android/graphics/drawable/DrawableContainer.java
@@ -181,7 +181,8 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
 
     @Override
     public int getOpacity() {
-        return mDrawableContainerState.getOpacity();
+        return mCurrDrawable == null || !mCurrDrawable.isVisible() ? PixelFormat.TRANSPARENT :
+                mDrawableContainerState.getOpacity();
     }
 
     public boolean selectDrawable(int idx)
@@ -336,13 +337,11 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return pos;
         }
 
-        public final int getChildCount()
-        {
+        public final int getChildCount() {
             return mNumChildren;
         }
 
-        public final Drawable[] getChildren()
-        {
+        public final Drawable[] getChildren() {
             return mDrawables;
         }
 
@@ -350,13 +349,11 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
           * all frames in the set (false), or to use the padding value of the frame 
           * being shown (true). Default value is false. 
           */
-        public final void setVariablePadding(boolean variable)
-        {
+        public final void setVariablePadding(boolean variable) {
             mVariablePadding = variable;
         }
 
-        public final Rect getConstantPadding()
-        {
+        public final Rect getConstantPadding() {
             if (mVariablePadding) {
                 return null;
             }
@@ -364,11 +361,12 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
                 return mConstantPadding;
             }
 
-            Rect r = new Rect(0, 0, 0, 0);
-            Rect t = new Rect();
+            final Rect r = new Rect(0, 0, 0, 0);
+            final Rect t = new Rect();
             final int N = getChildCount();
-            for (int i=0; i<N; i++) {
-                if (mDrawables[i].getPadding(t)) {
+            final Drawable[] drawables = mDrawables;
+            for (int i = 0; i < N; i++) {
+                if (drawables[i].getPadding(t)) {
                     if (t.left > r.left) r.left = t.left;
                     if (t.top > r.top) r.top = t.top;
                     if (t.right > r.right) r.right = t.right;
@@ -378,18 +376,15 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return (mConstantPadding=r);
         }
 
-        public final void setConstantSize(boolean constant)
-        {
+        public final void setConstantSize(boolean constant) {
             mConstantSize = constant;
         }
 
-        public final boolean isConstantSize()
-        {
+        public final boolean isConstantSize() {
             return mConstantSize;
         }
 
-        public final int getConstantWidth()
-        {
+        public final int getConstantWidth() {
             if (!mComputedConstantSize) {
                 computeConstantSize();
             }
@@ -397,8 +392,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return mConstantWidth;
         }
 
-        public final int getConstantHeight()
-        {
+        public final int getConstantHeight() {
             if (!mComputedConstantSize) {
                 computeConstantSize();
             }
@@ -406,8 +400,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return mConstantHeight;
         }
 
-        public final int getConstantMinimumWidth()
-        {
+        public final int getConstantMinimumWidth() {
             if (!mComputedConstantSize) {
                 computeConstantSize();
             }
@@ -415,8 +408,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return mConstantMinimumWidth;
         }
 
-        public final int getConstantMinimumHeight()
-        {
+        public final int getConstantMinimumHeight() {
             if (!mComputedConstantSize) {
                 computeConstantSize();
             }
@@ -424,15 +416,15 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return mConstantMinimumHeight;
         }
 
-        private void computeConstantSize()
-        {
+        private void computeConstantSize() {
             mComputedConstantSize = true;
 
             final int N = getChildCount();
+            final Drawable[] drawables = mDrawables;
             mConstantWidth = mConstantHeight = 0;
             mConstantMinimumWidth = mConstantMinimumHeight = 0;
-            for (int i=0; i<N; i++) {
-                Drawable dr = mDrawables[i];
+            for (int i = 0; i < N; i++) {
+                Drawable dr = drawables[i];
                 int s = dr.getIntrinsicWidth();
                 if (s > mConstantWidth) mConstantWidth = s;
                 s = dr.getIntrinsicHeight();
@@ -444,23 +436,22 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             }
         }
 
-        public final int getOpacity()
-        {
+        public final int getOpacity() {
             if (mHaveOpacity) {
                 return mOpacity;
             }
 
             final int N = getChildCount();
-            int op = N > 0
-                ? mDrawables[0].getOpacity() : PixelFormat.TRANSPARENT;
-            for (int i=1; i<N; i++) {
-                op = Drawable.resolveOpacity(op, mDrawables[i].getOpacity());
+            final Drawable[] drawables = mDrawables;
+            int op = N > 0 ? drawables[0].getOpacity() : PixelFormat.TRANSPARENT;
+            for (int i = 1; i < N; i++) {
+                op = Drawable.resolveOpacity(op, drawables[i].getOpacity());
             }
             mOpacity = op;
             mHaveOpacity = true;
             return op;
         }
-        
+
         public final boolean isStateful() {
             if (mHaveStateful) {
                 return mStateful;
@@ -480,8 +471,7 @@ public class DrawableContainer extends Drawable implements Drawable.Callback {
             return stateful;
         }
 
-        public void growArray(int oldSize, int newSize)
-        {
+        public void growArray(int oldSize, int newSize) {
             Drawable[] newDrawables = new Drawable[newSize];
             System.arraycopy(mDrawables, 0, newDrawables, 0, oldSize);
             mDrawables = newDrawables;