1/*
2 * Copyright (C) 2006 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.graphics.drawable;
18
19import android.content.res.ColorStateList;
20import android.content.res.Resources;
21import android.content.res.TypedArray;
22import android.content.res.Resources.Theme;
23import android.graphics.Canvas;
24import android.graphics.Color;
25import android.graphics.ColorFilter;
26import android.graphics.DashPathEffect;
27import android.graphics.LinearGradient;
28import android.graphics.Outline;
29import android.graphics.Paint;
30import android.graphics.Path;
31import android.graphics.PixelFormat;
32import android.graphics.PorterDuff;
33import android.graphics.PorterDuffColorFilter;
34import android.graphics.RadialGradient;
35import android.graphics.Rect;
36import android.graphics.RectF;
37import android.graphics.Shader;
38import android.graphics.SweepGradient;
39import android.util.AttributeSet;
40import android.util.Log;
41import android.util.TypedValue;
42
43import com.android.internal.R;
44
45import org.xmlpull.v1.XmlPullParser;
46import org.xmlpull.v1.XmlPullParserException;
47
48import java.io.IOException;
49
50/**
51 * A Drawable with a color gradient for buttons, backgrounds, etc.
52 *
53 * <p>It can be defined in an XML file with the <code>&lt;shape></code> element. For more
54 * information, see the guide to <a
55 * href="{@docRoot}guide/topics/resources/drawable-resource.html">Drawable Resources</a>.</p>
56 *
57 * @attr ref android.R.styleable#GradientDrawable_visible
58 * @attr ref android.R.styleable#GradientDrawable_shape
59 * @attr ref android.R.styleable#GradientDrawable_innerRadiusRatio
60 * @attr ref android.R.styleable#GradientDrawable_innerRadius
61 * @attr ref android.R.styleable#GradientDrawable_thicknessRatio
62 * @attr ref android.R.styleable#GradientDrawable_thickness
63 * @attr ref android.R.styleable#GradientDrawable_useLevel
64 * @attr ref android.R.styleable#GradientDrawableSize_width
65 * @attr ref android.R.styleable#GradientDrawableSize_height
66 * @attr ref android.R.styleable#GradientDrawableGradient_startColor
67 * @attr ref android.R.styleable#GradientDrawableGradient_centerColor
68 * @attr ref android.R.styleable#GradientDrawableGradient_endColor
69 * @attr ref android.R.styleable#GradientDrawableGradient_useLevel
70 * @attr ref android.R.styleable#GradientDrawableGradient_angle
71 * @attr ref android.R.styleable#GradientDrawableGradient_type
72 * @attr ref android.R.styleable#GradientDrawableGradient_centerX
73 * @attr ref android.R.styleable#GradientDrawableGradient_centerY
74 * @attr ref android.R.styleable#GradientDrawableGradient_gradientRadius
75 * @attr ref android.R.styleable#GradientDrawableSolid_color
76 * @attr ref android.R.styleable#GradientDrawableStroke_width
77 * @attr ref android.R.styleable#GradientDrawableStroke_color
78 * @attr ref android.R.styleable#GradientDrawableStroke_dashWidth
79 * @attr ref android.R.styleable#GradientDrawableStroke_dashGap
80 * @attr ref android.R.styleable#GradientDrawablePadding_left
81 * @attr ref android.R.styleable#GradientDrawablePadding_top
82 * @attr ref android.R.styleable#GradientDrawablePadding_right
83 * @attr ref android.R.styleable#GradientDrawablePadding_bottom
84 */
85public class GradientDrawable extends Drawable {
86    /**
87     * Shape is a rectangle, possibly with rounded corners
88     */
89    public static final int RECTANGLE = 0;
90
91    /**
92     * Shape is an ellipse
93     */
94    public static final int OVAL = 1;
95
96    /**
97     * Shape is a line
98     */
99    public static final int LINE = 2;
100
101    /**
102     * Shape is a ring.
103     */
104    public static final int RING = 3;
105
106    /**
107     * Gradient is linear (default.)
108     */
109    public static final int LINEAR_GRADIENT = 0;
110
111    /**
112     * Gradient is circular.
113     */
114    public static final int RADIAL_GRADIENT = 1;
115
116    /**
117     * Gradient is a sweep.
118     */
119    public static final int SWEEP_GRADIENT  = 2;
120
121    /** Radius is in pixels. */
122    private static final int RADIUS_TYPE_PIXELS = 0;
123
124    /** Radius is a fraction of the base size. */
125    private static final int RADIUS_TYPE_FRACTION = 1;
126
127    /** Radius is a fraction of the bounds size. */
128    private static final int RADIUS_TYPE_FRACTION_PARENT = 2;
129
130    private static final float DEFAULT_INNER_RADIUS_RATIO = 3.0f;
131    private static final float DEFAULT_THICKNESS_RATIO = 9.0f;
132
133    private GradientState mGradientState;
134
135    private final Paint mFillPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
136    private Rect mPadding;
137    private Paint mStrokePaint;   // optional, set by the caller
138    private ColorFilter mColorFilter;   // optional, set by the caller
139    private PorterDuffColorFilter mTintFilter;
140    private int mAlpha = 0xFF;  // modified by the caller
141
142    private final Path mPath = new Path();
143    private final RectF mRect = new RectF();
144
145    private Paint mLayerPaint;    // internal, used if we use saveLayer()
146    private boolean mGradientIsDirty;   // internal state
147    private boolean mMutated;
148    private Path mRingPath;
149    private boolean mPathIsDirty = true;
150
151    /** Current gradient radius, valid when {@link #mGradientIsDirty} is false. */
152    private float mGradientRadius;
153
154    /**
155     * Controls how the gradient is oriented relative to the drawable's bounds
156     */
157    public enum Orientation {
158        /** draw the gradient from the top to the bottom */
159        TOP_BOTTOM,
160        /** draw the gradient from the top-right to the bottom-left */
161        TR_BL,
162        /** draw the gradient from the right to the left */
163        RIGHT_LEFT,
164        /** draw the gradient from the bottom-right to the top-left */
165        BR_TL,
166        /** draw the gradient from the bottom to the top */
167        BOTTOM_TOP,
168        /** draw the gradient from the bottom-left to the top-right */
169        BL_TR,
170        /** draw the gradient from the left to the right */
171        LEFT_RIGHT,
172        /** draw the gradient from the top-left to the bottom-right */
173        TL_BR,
174    }
175
176    public GradientDrawable() {
177        this(new GradientState(Orientation.TOP_BOTTOM, null));
178    }
179
180    /**
181     * Create a new gradient drawable given an orientation and an array
182     * of colors for the gradient.
183     */
184    public GradientDrawable(Orientation orientation, int[] colors) {
185        this(new GradientState(orientation, colors));
186    }
187
188    @Override
189    public boolean getPadding(Rect padding) {
190        if (mPadding != null) {
191            padding.set(mPadding);
192            return true;
193        } else {
194            return super.getPadding(padding);
195        }
196    }
197
198    /**
199     * <p>Specify radii for each of the 4 corners. For each corner, the array
200     * contains 2 values, <code>[X_radius, Y_radius]</code>. The corners are ordered
201     * top-left, top-right, bottom-right, bottom-left. This property
202     * is honored only when the shape is of type {@link #RECTANGLE}.</p>
203     * <p><strong>Note</strong>: changing this property will affect all instances
204     * of a drawable loaded from a resource. It is recommended to invoke
205     * {@link #mutate()} before changing this property.</p>
206     *
207     * @param radii 4 pairs of X and Y radius for each corner, specified in pixels.
208     *              The length of this array must be >= 8
209     *
210     * @see #mutate()
211     * @see #setCornerRadii(float[])
212     * @see #setShape(int)
213     */
214    public void setCornerRadii(float[] radii) {
215        mGradientState.setCornerRadii(radii);
216        mPathIsDirty = true;
217        invalidateSelf();
218    }
219
220    /**
221     * <p>Specify radius for the corners of the gradient. If this is > 0, then the
222     * drawable is drawn in a round-rectangle, rather than a rectangle. This property
223     * is honored only when the shape is of type {@link #RECTANGLE}.</p>
224     * <p><strong>Note</strong>: changing this property will affect all instances
225     * of a drawable loaded from a resource. It is recommended to invoke
226     * {@link #mutate()} before changing this property.</p>
227     *
228     * @param radius The radius in pixels of the corners of the rectangle shape
229     *
230     * @see #mutate()
231     * @see #setCornerRadii(float[])
232     * @see #setShape(int)
233     */
234    public void setCornerRadius(float radius) {
235        mGradientState.setCornerRadius(radius);
236        mPathIsDirty = true;
237        invalidateSelf();
238    }
239
240    /**
241     * <p>Set the stroke width and color for the drawable. If width is zero,
242     * then no stroke is drawn.</p>
243     * <p><strong>Note</strong>: changing this property will affect all instances
244     * of a drawable loaded from a resource. It is recommended to invoke
245     * {@link #mutate()} before changing this property.</p>
246     *
247     * @param width The width in pixels of the stroke
248     * @param color The color of the stroke
249     *
250     * @see #mutate()
251     * @see #setStroke(int, int, float, float)
252     */
253    public void setStroke(int width, int color) {
254        setStroke(width, color, 0, 0);
255    }
256
257    /**
258     * <p>Set the stroke width and color state list for the drawable. If width
259     * is zero, then no stroke is drawn.</p>
260     * <p><strong>Note</strong>: changing this property will affect all instances
261     * of a drawable loaded from a resource. It is recommended to invoke
262     * {@link #mutate()} before changing this property.</p>
263     *
264     * @param width The width in pixels of the stroke
265     * @param colorStateList The color state list of the stroke
266     *
267     * @see #mutate()
268     * @see #setStroke(int, ColorStateList, float, float)
269     */
270    public void setStroke(int width, ColorStateList colorStateList) {
271        setStroke(width, colorStateList, 0, 0);
272    }
273
274    /**
275     * <p>Set the stroke width and color for the drawable. If width is zero,
276     * then no stroke is drawn. This method can also be used to dash the stroke.</p>
277     * <p><strong>Note</strong>: changing this property will affect all instances
278     * of a drawable loaded from a resource. It is recommended to invoke
279     * {@link #mutate()} before changing this property.</p>
280     *
281     * @param width The width in pixels of the stroke
282     * @param color The color of the stroke
283     * @param dashWidth The length in pixels of the dashes, set to 0 to disable dashes
284     * @param dashGap The gap in pixels between dashes
285     *
286     * @see #mutate()
287     * @see #setStroke(int, int)
288     */
289    public void setStroke(int width, int color, float dashWidth, float dashGap) {
290        mGradientState.setStroke(width, ColorStateList.valueOf(color), dashWidth, dashGap);
291        setStrokeInternal(width, color, dashWidth, dashGap);
292    }
293
294    /**
295     * <p>Set the stroke width and color state list for the drawable. If width
296     * is zero, then no stroke is drawn. This method can also be used to dash
297     * the stroke.</p>
298     * <p><strong>Note</strong>: changing this property will affect all instances
299     * of a drawable loaded from a resource. It is recommended to invoke
300     * {@link #mutate()} before changing this property.</p>
301     *
302     * @param width The width in pixels of the stroke
303     * @param colorStateList The color state list of the stroke
304     * @param dashWidth The length in pixels of the dashes, set to 0 to disable dashes
305     * @param dashGap The gap in pixels between dashes
306     *
307     * @see #mutate()
308     * @see #setStroke(int, ColorStateList)
309     */
310    public void setStroke(
311            int width, ColorStateList colorStateList, float dashWidth, float dashGap) {
312        mGradientState.setStroke(width, colorStateList, dashWidth, dashGap);
313        final int color;
314        if (colorStateList == null) {
315            color = Color.TRANSPARENT;
316        } else {
317            final int[] stateSet = getState();
318            color = colorStateList.getColorForState(stateSet, 0);
319        }
320        setStrokeInternal(width, color, dashWidth, dashGap);
321    }
322
323    private void setStrokeInternal(int width, int color, float dashWidth, float dashGap) {
324        if (mStrokePaint == null)  {
325            mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
326            mStrokePaint.setStyle(Paint.Style.STROKE);
327        }
328        mStrokePaint.setStrokeWidth(width);
329        mStrokePaint.setColor(color);
330
331        DashPathEffect e = null;
332        if (dashWidth > 0) {
333            e = new DashPathEffect(new float[] { dashWidth, dashGap }, 0);
334        }
335        mStrokePaint.setPathEffect(e);
336        invalidateSelf();
337    }
338
339
340    /**
341     * <p>Sets the size of the shape drawn by this drawable.</p>
342     * <p><strong>Note</strong>: changing this property will affect all instances
343     * of a drawable loaded from a resource. It is recommended to invoke
344     * {@link #mutate()} before changing this property.</p>
345     *
346     * @param width The width of the shape used by this drawable
347     * @param height The height of the shape used by this drawable
348     *
349     * @see #mutate()
350     * @see #setGradientType(int)
351     */
352    public void setSize(int width, int height) {
353        mGradientState.setSize(width, height);
354        mPathIsDirty = true;
355        invalidateSelf();
356    }
357
358    /**
359     * <p>Sets the type of shape used to draw the gradient.</p>
360     * <p><strong>Note</strong>: changing this property will affect all instances
361     * of a drawable loaded from a resource. It is recommended to invoke
362     * {@link #mutate()} before changing this property.</p>
363     *
364     * @param shape The desired shape for this drawable: {@link #LINE},
365     *              {@link #OVAL}, {@link #RECTANGLE} or {@link #RING}
366     *
367     * @see #mutate()
368     */
369    public void setShape(int shape) {
370        mRingPath = null;
371        mPathIsDirty = true;
372        mGradientState.setShape(shape);
373        invalidateSelf();
374    }
375
376    /**
377     * <p>Sets the type of gradient used by this drawable..</p>
378     * <p><strong>Note</strong>: changing this property will affect all instances
379     * of a drawable loaded from a resource. It is recommended to invoke
380     * {@link #mutate()} before changing this property.</p>
381     *
382     * @param gradient The type of the gradient: {@link #LINEAR_GRADIENT},
383     *                 {@link #RADIAL_GRADIENT} or {@link #SWEEP_GRADIENT}
384     *
385     * @see #mutate()
386     */
387    public void setGradientType(int gradient) {
388        mGradientState.setGradientType(gradient);
389        mGradientIsDirty = true;
390        invalidateSelf();
391    }
392
393    /**
394     * <p>Sets the center location of the gradient. The radius is honored only when
395     * the gradient type is set to {@link #RADIAL_GRADIENT} or {@link #SWEEP_GRADIENT}.</p>
396     * <p><strong>Note</strong>: changing this property will affect all instances
397     * of a drawable loaded from a resource. It is recommended to invoke
398     * {@link #mutate()} before changing this property.</p>
399     *
400     * @param x The x coordinate of the gradient's center
401     * @param y The y coordinate of the gradient's center
402     *
403     * @see #mutate()
404     * @see #setGradientType(int)
405     */
406    public void setGradientCenter(float x, float y) {
407        mGradientState.setGradientCenter(x, y);
408        mGradientIsDirty = true;
409        invalidateSelf();
410    }
411
412    /**
413     * <p>Sets the radius of the gradient. The radius is honored only when the
414     * gradient type is set to {@link #RADIAL_GRADIENT}.</p>
415     * <p><strong>Note</strong>: changing this property will affect all instances
416     * of a drawable loaded from a resource. It is recommended to invoke
417     * {@link #mutate()} before changing this property.</p>
418     *
419     * @param gradientRadius The radius of the gradient in pixels
420     *
421     * @see #mutate()
422     * @see #setGradientType(int)
423     */
424    public void setGradientRadius(float gradientRadius) {
425        mGradientState.setGradientRadius(gradientRadius, TypedValue.COMPLEX_UNIT_PX);
426        mGradientIsDirty = true;
427        invalidateSelf();
428    }
429
430    /**
431     * Returns the radius of the gradient in pixels. The radius is valid only
432     * when the gradient type is set to {@link #RADIAL_GRADIENT}.
433     *
434     * @return Radius in pixels.
435     */
436    public float getGradientRadius() {
437        if (mGradientState.mGradient != RADIAL_GRADIENT) {
438            return 0;
439        }
440
441        ensureValidRect();
442        return mGradientRadius;
443    }
444
445    /**
446     * <p>Sets whether or not this drawable will honor its <code>level</code>
447     * property.</p>
448     * <p><strong>Note</strong>: changing this property will affect all instances
449     * of a drawable loaded from a resource. It is recommended to invoke
450     * {@link #mutate()} before changing this property.</p>
451     *
452     * @param useLevel True if this drawable should honor its level, false otherwise
453     *
454     * @see #mutate()
455     * @see #setLevel(int)
456     * @see #getLevel()
457     */
458    public void setUseLevel(boolean useLevel) {
459        mGradientState.mUseLevel = useLevel;
460        mGradientIsDirty = true;
461        invalidateSelf();
462    }
463
464    private int modulateAlpha(int alpha) {
465        int scale = mAlpha + (mAlpha >> 7);
466        return alpha * scale >> 8;
467    }
468
469    /**
470     * Returns the orientation of the gradient defined in this drawable.
471     */
472    public Orientation getOrientation() {
473        return mGradientState.mOrientation;
474    }
475
476    /**
477     * <p>Changes the orientation of the gradient defined in this drawable.</p>
478     * <p><strong>Note</strong>: changing orientation will affect all instances
479     * of a drawable loaded from a resource. It is recommended to invoke
480     * {@link #mutate()} before changing the orientation.</p>
481     *
482     * @param orientation The desired orientation (angle) of the gradient
483     *
484     * @see #mutate()
485     */
486    public void setOrientation(Orientation orientation) {
487        mGradientState.mOrientation = orientation;
488        mGradientIsDirty = true;
489        invalidateSelf();
490    }
491
492    /**
493     * <p>Sets the colors used to draw the gradient. Each color is specified as an
494     * ARGB integer and the array must contain at least 2 colors.</p>
495     * <p><strong>Note</strong>: changing orientation will affect all instances
496     * of a drawable loaded from a resource. It is recommended to invoke
497     * {@link #mutate()} before changing the orientation.</p>
498     *
499     * @param colors 2 or more ARGB colors
500     *
501     * @see #mutate()
502     * @see #setColor(int)
503     */
504    public void setColors(int[] colors) {
505        mGradientState.setColors(colors);
506        mGradientIsDirty = true;
507        invalidateSelf();
508    }
509
510    @Override
511    public void draw(Canvas canvas) {
512        if (!ensureValidRect()) {
513            // nothing to draw
514            return;
515        }
516
517        // remember the alpha values, in case we temporarily overwrite them
518        // when we modulate them with mAlpha
519        final int prevFillAlpha = mFillPaint.getAlpha();
520        final int prevStrokeAlpha = mStrokePaint != null ? mStrokePaint.getAlpha() : 0;
521        // compute the modulate alpha values
522        final int currFillAlpha = modulateAlpha(prevFillAlpha);
523        final int currStrokeAlpha = modulateAlpha(prevStrokeAlpha);
524
525        final boolean haveStroke = currStrokeAlpha > 0 && mStrokePaint != null &&
526                mStrokePaint.getStrokeWidth() > 0;
527        final boolean haveFill = currFillAlpha > 0;
528        final GradientState st = mGradientState;
529        final ColorFilter colorFilter = mColorFilter != null ? mColorFilter : mTintFilter;
530
531        /*  we need a layer iff we're drawing both a fill and stroke, and the
532            stroke is non-opaque, and our shapetype actually supports
533            fill+stroke. Otherwise we can just draw the stroke (if any) on top
534            of the fill (if any) without worrying about blending artifacts.
535         */
536        final boolean useLayer = haveStroke && haveFill && st.mShape != LINE &&
537                 currStrokeAlpha < 255 && (mAlpha < 255 || colorFilter != null);
538
539        /*  Drawing with a layer is slower than direct drawing, but it
540            allows us to apply paint effects like alpha and colorfilter to
541            the result of multiple separate draws. In our case, if the user
542            asks for a non-opaque alpha value (via setAlpha), and we're
543            stroking, then we need to apply the alpha AFTER we've drawn
544            both the fill and the stroke.
545        */
546        if (useLayer) {
547            if (mLayerPaint == null) {
548                mLayerPaint = new Paint();
549            }
550            mLayerPaint.setDither(st.mDither);
551            mLayerPaint.setAlpha(mAlpha);
552            mLayerPaint.setColorFilter(colorFilter);
553
554            float rad = mStrokePaint.getStrokeWidth();
555            canvas.saveLayer(mRect.left - rad, mRect.top - rad,
556                             mRect.right + rad, mRect.bottom + rad,
557                             mLayerPaint, Canvas.HAS_ALPHA_LAYER_SAVE_FLAG);
558
559            // don't perform the filter in our individual paints
560            // since the layer will do it for us
561            mFillPaint.setColorFilter(null);
562            mStrokePaint.setColorFilter(null);
563        } else {
564            /*  if we're not using a layer, apply the dither/filter to our
565                individual paints
566            */
567            mFillPaint.setAlpha(currFillAlpha);
568            mFillPaint.setDither(st.mDither);
569            mFillPaint.setColorFilter(colorFilter);
570            if (colorFilter != null && st.mColorStateList == null) {
571                mFillPaint.setColor(mAlpha << 24);
572            }
573            if (haveStroke) {
574                mStrokePaint.setAlpha(currStrokeAlpha);
575                mStrokePaint.setDither(st.mDither);
576                mStrokePaint.setColorFilter(colorFilter);
577            }
578        }
579
580        switch (st.mShape) {
581            case RECTANGLE:
582                if (st.mRadiusArray != null) {
583                    buildPathIfDirty();
584                    canvas.drawPath(mPath, mFillPaint);
585                    if (haveStroke) {
586                        canvas.drawPath(mPath, mStrokePaint);
587                    }
588                } else if (st.mRadius > 0.0f) {
589                    // since the caller is only giving us 1 value, we will force
590                    // it to be square if the rect is too small in one dimension
591                    // to show it. If we did nothing, Skia would clamp the rad
592                    // independently along each axis, giving us a thin ellipse
593                    // if the rect were very wide but not very tall
594                    float rad = Math.min(st.mRadius,
595                            Math.min(mRect.width(), mRect.height()) * 0.5f);
596                    canvas.drawRoundRect(mRect, rad, rad, mFillPaint);
597                    if (haveStroke) {
598                        canvas.drawRoundRect(mRect, rad, rad, mStrokePaint);
599                    }
600                } else {
601                    if (mFillPaint.getColor() != 0 || colorFilter != null ||
602                            mFillPaint.getShader() != null) {
603                        canvas.drawRect(mRect, mFillPaint);
604                    }
605                    if (haveStroke) {
606                        canvas.drawRect(mRect, mStrokePaint);
607                    }
608                }
609                break;
610            case OVAL:
611                canvas.drawOval(mRect, mFillPaint);
612                if (haveStroke) {
613                    canvas.drawOval(mRect, mStrokePaint);
614                }
615                break;
616            case LINE: {
617                RectF r = mRect;
618                float y = r.centerY();
619                if (haveStroke) {
620                    canvas.drawLine(r.left, y, r.right, y, mStrokePaint);
621                }
622                break;
623            }
624            case RING:
625                Path path = buildRing(st);
626                canvas.drawPath(path, mFillPaint);
627                if (haveStroke) {
628                    canvas.drawPath(path, mStrokePaint);
629                }
630                break;
631        }
632
633        if (useLayer) {
634            canvas.restore();
635        } else {
636            mFillPaint.setAlpha(prevFillAlpha);
637            if (haveStroke) {
638                mStrokePaint.setAlpha(prevStrokeAlpha);
639            }
640        }
641    }
642
643    private void buildPathIfDirty() {
644        final GradientState st = mGradientState;
645        if (mPathIsDirty) {
646            ensureValidRect();
647            mPath.reset();
648            mPath.addRoundRect(mRect, st.mRadiusArray, Path.Direction.CW);
649            mPathIsDirty = false;
650        }
651    }
652
653    private Path buildRing(GradientState st) {
654        if (mRingPath != null && (!st.mUseLevelForShape || !mPathIsDirty)) return mRingPath;
655        mPathIsDirty = false;
656
657        float sweep = st.mUseLevelForShape ? (360.0f * getLevel() / 10000.0f) : 360f;
658
659        RectF bounds = new RectF(mRect);
660
661        float x = bounds.width() / 2.0f;
662        float y = bounds.height() / 2.0f;
663
664        float thickness = st.mThickness != -1 ?
665                st.mThickness : bounds.width() / st.mThicknessRatio;
666        // inner radius
667        float radius = st.mInnerRadius != -1 ?
668                st.mInnerRadius : bounds.width() / st.mInnerRadiusRatio;
669
670        RectF innerBounds = new RectF(bounds);
671        innerBounds.inset(x - radius, y - radius);
672
673        bounds = new RectF(innerBounds);
674        bounds.inset(-thickness, -thickness);
675
676        if (mRingPath == null) {
677            mRingPath = new Path();
678        } else {
679            mRingPath.reset();
680        }
681
682        final Path ringPath = mRingPath;
683        // arcTo treats the sweep angle mod 360, so check for that, since we
684        // think 360 means draw the entire oval
685        if (sweep < 360 && sweep > -360) {
686            ringPath.setFillType(Path.FillType.EVEN_ODD);
687            // inner top
688            ringPath.moveTo(x + radius, y);
689            // outer top
690            ringPath.lineTo(x + radius + thickness, y);
691            // outer arc
692            ringPath.arcTo(bounds, 0.0f, sweep, false);
693            // inner arc
694            ringPath.arcTo(innerBounds, sweep, -sweep, false);
695            ringPath.close();
696        } else {
697            // add the entire ovals
698            ringPath.addOval(bounds, Path.Direction.CW);
699            ringPath.addOval(innerBounds, Path.Direction.CCW);
700        }
701
702        return ringPath;
703    }
704
705    /**
706     * <p>Changes this drawable to use a single color instead of a gradient.</p>
707     * <p><strong>Note</strong>: changing color will affect all instances
708     * of a drawable loaded from a resource. It is recommended to invoke
709     * {@link #mutate()} before changing the color.</p>
710     *
711     * @param argb The color used to fill the shape
712     *
713     * @see #mutate()
714     * @see #setColors(int[])
715     */
716    public void setColor(int argb) {
717        mGradientState.setColorStateList(ColorStateList.valueOf(argb));
718        mFillPaint.setColor(argb);
719        invalidateSelf();
720    }
721
722    /**
723     * Changes this drawable to use a single color state list instead of a
724     * gradient. Calling this method with a null argument will clear the color
725     * and is equivalent to calling {@link #setColor(int)} with the argument
726     * {@link Color#TRANSPARENT}.
727     * <p>
728     * <strong>Note</strong>: changing color will affect all instances of a
729     * drawable loaded from a resource. It is recommended to invoke
730     * {@link #mutate()} before changing the color.</p>
731     *
732     * @param colorStateList The color state list used to fill the shape
733     * @see #mutate()
734     */
735    public void setColor(ColorStateList colorStateList) {
736        mGradientState.setColorStateList(colorStateList);
737        final int color;
738        if (colorStateList == null) {
739            color = Color.TRANSPARENT;
740        } else {
741            final int[] stateSet = getState();
742            color = colorStateList.getColorForState(stateSet, 0);
743        }
744        mFillPaint.setColor(color);
745        invalidateSelf();
746    }
747
748    @Override
749    protected boolean onStateChange(int[] stateSet) {
750        boolean invalidateSelf = false;
751
752        final GradientState s = mGradientState;
753        final ColorStateList stateList = s.mColorStateList;
754        if (stateList != null) {
755            final int newColor = stateList.getColorForState(stateSet, 0);
756            final int oldColor = mFillPaint.getColor();
757            if (oldColor != newColor) {
758                mFillPaint.setColor(newColor);
759                invalidateSelf = true;
760            }
761        }
762
763        final Paint strokePaint = mStrokePaint;
764        if (strokePaint != null) {
765            final ColorStateList strokeStateList = s.mStrokeColorStateList;
766            if (strokeStateList != null) {
767                final int newStrokeColor = strokeStateList.getColorForState(stateSet, 0);
768                final int oldStrokeColor = strokePaint.getColor();
769                if (oldStrokeColor != newStrokeColor) {
770                    strokePaint.setColor(newStrokeColor);
771                    invalidateSelf = true;
772                }
773            }
774        }
775
776        if (s.mTint != null && s.mTintMode != null) {
777            mTintFilter = updateTintFilter(mTintFilter, s.mTint, s.mTintMode);
778            invalidateSelf = true;
779        }
780
781        if (invalidateSelf) {
782            invalidateSelf();
783            return true;
784        }
785
786        return false;
787    }
788
789    @Override
790    public boolean isStateful() {
791        final GradientState s = mGradientState;
792        return super.isStateful()
793                || (s.mColorStateList != null && s.mColorStateList.isStateful())
794                || (s.mStrokeColorStateList != null && s.mStrokeColorStateList.isStateful())
795                || (s.mTint != null && s.mTint.isStateful());
796    }
797
798    @Override
799    public int getChangingConfigurations() {
800        return super.getChangingConfigurations() | mGradientState.mChangingConfigurations;
801    }
802
803    @Override
804    public void setAlpha(int alpha) {
805        if (alpha != mAlpha) {
806            mAlpha = alpha;
807            invalidateSelf();
808        }
809    }
810
811    @Override
812    public int getAlpha() {
813        return mAlpha;
814    }
815
816    @Override
817    public void setDither(boolean dither) {
818        if (dither != mGradientState.mDither) {
819            mGradientState.mDither = dither;
820            invalidateSelf();
821        }
822    }
823
824    @Override
825    public ColorFilter getColorFilter() {
826        return mColorFilter;
827    }
828
829    @Override
830    public void setColorFilter(ColorFilter cf) {
831        if (cf != mColorFilter) {
832            mColorFilter = cf;
833            invalidateSelf();
834        }
835    }
836
837    @Override
838    public void setTintList(ColorStateList tint) {
839        mGradientState.mTint = tint;
840        mTintFilter = updateTintFilter(mTintFilter, tint, mGradientState.mTintMode);
841        invalidateSelf();
842    }
843
844    @Override
845    public void setTintMode(PorterDuff.Mode tintMode) {
846        mGradientState.mTintMode = tintMode;
847        mTintFilter = updateTintFilter(mTintFilter, mGradientState.mTint, tintMode);
848        invalidateSelf();
849    }
850
851    @Override
852    public int getOpacity() {
853        return (mAlpha == 255 && mGradientState.mOpaqueOverBounds && isOpaqueForState()) ?
854                PixelFormat.OPAQUE : PixelFormat.TRANSLUCENT;
855    }
856
857    @Override
858    protected void onBoundsChange(Rect r) {
859        super.onBoundsChange(r);
860        mRingPath = null;
861        mPathIsDirty = true;
862        mGradientIsDirty = true;
863    }
864
865    @Override
866    protected boolean onLevelChange(int level) {
867        super.onLevelChange(level);
868        mGradientIsDirty = true;
869        mPathIsDirty = true;
870        invalidateSelf();
871        return true;
872    }
873
874    /**
875     * This checks mGradientIsDirty, and if it is true, recomputes both our drawing
876     * rectangle (mRect) and the gradient itself, since it depends on our
877     * rectangle too.
878     * @return true if the resulting rectangle is not empty, false otherwise
879     */
880    private boolean ensureValidRect() {
881        if (mGradientIsDirty) {
882            mGradientIsDirty = false;
883
884            Rect bounds = getBounds();
885            float inset = 0;
886
887            if (mStrokePaint != null) {
888                inset = mStrokePaint.getStrokeWidth() * 0.5f;
889            }
890
891            final GradientState st = mGradientState;
892
893            mRect.set(bounds.left + inset, bounds.top + inset,
894                      bounds.right - inset, bounds.bottom - inset);
895
896            final int[] colors = st.mColors;
897            if (colors != null) {
898                RectF r = mRect;
899                float x0, x1, y0, y1;
900
901                if (st.mGradient == LINEAR_GRADIENT) {
902                    final float level = st.mUseLevel ? getLevel() / 10000.0f : 1.0f;
903                    switch (st.mOrientation) {
904                    case TOP_BOTTOM:
905                        x0 = r.left;            y0 = r.top;
906                        x1 = x0;                y1 = level * r.bottom;
907                        break;
908                    case TR_BL:
909                        x0 = r.right;           y0 = r.top;
910                        x1 = level * r.left;    y1 = level * r.bottom;
911                        break;
912                    case RIGHT_LEFT:
913                        x0 = r.right;           y0 = r.top;
914                        x1 = level * r.left;    y1 = y0;
915                        break;
916                    case BR_TL:
917                        x0 = r.right;           y0 = r.bottom;
918                        x1 = level * r.left;    y1 = level * r.top;
919                        break;
920                    case BOTTOM_TOP:
921                        x0 = r.left;            y0 = r.bottom;
922                        x1 = x0;                y1 = level * r.top;
923                        break;
924                    case BL_TR:
925                        x0 = r.left;            y0 = r.bottom;
926                        x1 = level * r.right;   y1 = level * r.top;
927                        break;
928                    case LEFT_RIGHT:
929                        x0 = r.left;            y0 = r.top;
930                        x1 = level * r.right;   y1 = y0;
931                        break;
932                    default:/* TL_BR */
933                        x0 = r.left;            y0 = r.top;
934                        x1 = level * r.right;   y1 = level * r.bottom;
935                        break;
936                    }
937
938                    mFillPaint.setShader(new LinearGradient(x0, y0, x1, y1,
939                            colors, st.mPositions, Shader.TileMode.CLAMP));
940                } else if (st.mGradient == RADIAL_GRADIENT) {
941                    x0 = r.left + (r.right - r.left) * st.mCenterX;
942                    y0 = r.top + (r.bottom - r.top) * st.mCenterY;
943
944                    float radius = st.mGradientRadius;
945                    if (st.mGradientRadiusType == RADIUS_TYPE_FRACTION) {
946                        // Fall back to parent width or height if intrinsic
947                        // size is not specified.
948                        final float width = st.mWidth >= 0 ? st.mWidth : r.width();
949                        final float height = st.mHeight >= 0 ? st.mHeight : r.height();
950                        radius *= Math.min(width, height);
951                    } else if (st.mGradientRadiusType == RADIUS_TYPE_FRACTION_PARENT) {
952                        radius *= Math.min(r.width(), r.height());
953                    }
954
955                    if (st.mUseLevel) {
956                        radius *= getLevel() / 10000.0f;
957                    }
958
959                    mGradientRadius = radius;
960
961                    if (radius <= 0) {
962                        // We can't have a shader with non-positive radius, so
963                        // let's have a very, very small radius.
964                        radius = 0.001f;
965                    }
966
967                    mFillPaint.setShader(new RadialGradient(
968                            x0, y0, radius, colors, null, Shader.TileMode.CLAMP));
969                } else if (st.mGradient == SWEEP_GRADIENT) {
970                    x0 = r.left + (r.right - r.left) * st.mCenterX;
971                    y0 = r.top + (r.bottom - r.top) * st.mCenterY;
972
973                    int[] tempColors = colors;
974                    float[] tempPositions = null;
975
976                    if (st.mUseLevel) {
977                        tempColors = st.mTempColors;
978                        final int length = colors.length;
979                        if (tempColors == null || tempColors.length != length + 1) {
980                            tempColors = st.mTempColors = new int[length + 1];
981                        }
982                        System.arraycopy(colors, 0, tempColors, 0, length);
983                        tempColors[length] = colors[length - 1];
984
985                        tempPositions = st.mTempPositions;
986                        final float fraction = 1.0f / (length - 1);
987                        if (tempPositions == null || tempPositions.length != length + 1) {
988                            tempPositions = st.mTempPositions = new float[length + 1];
989                        }
990
991                        final float level = getLevel() / 10000.0f;
992                        for (int i = 0; i < length; i++) {
993                            tempPositions[i] = i * fraction * level;
994                        }
995                        tempPositions[length] = 1.0f;
996
997                    }
998                    mFillPaint.setShader(new SweepGradient(x0, y0, tempColors, tempPositions));
999                }
1000
1001                // If we don't have a solid color, the alpha channel must be
1002                // maxed out so that alpha modulation works correctly.
1003                if (st.mColorStateList == null) {
1004                    mFillPaint.setColor(Color.BLACK);
1005                }
1006            }
1007        }
1008        return !mRect.isEmpty();
1009    }
1010
1011    @Override
1012    public void inflate(Resources r, XmlPullParser parser, AttributeSet attrs, Theme theme)
1013            throws XmlPullParserException, IOException {
1014        final TypedArray a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawable);
1015        super.inflateWithAttributes(r, parser, a, R.styleable.GradientDrawable_visible);
1016        updateStateFromTypedArray(a);
1017        a.recycle();
1018
1019        inflateChildElements(r, parser, attrs, theme);
1020
1021        mGradientState.computeOpacity();
1022    }
1023
1024    @Override
1025    public void applyTheme(Theme t) {
1026        super.applyTheme(t);
1027
1028        final GradientState state = mGradientState;
1029        if (state == null) {
1030            return;
1031        }
1032
1033        if (state.mThemeAttrs != null) {
1034            final TypedArray a = t.resolveAttributes(
1035                    state.mThemeAttrs, R.styleable.GradientDrawable);
1036            updateStateFromTypedArray(a);
1037            a.recycle();
1038        }
1039
1040        applyThemeChildElements(t);
1041
1042        state.computeOpacity();
1043    }
1044
1045    /**
1046     * Updates the constant state from the values in the typed array.
1047     */
1048    private void updateStateFromTypedArray(TypedArray a) {
1049        final GradientState state = mGradientState;
1050
1051        // Account for any configuration changes.
1052        state.mChangingConfigurations |= a.getChangingConfigurations();
1053
1054        // Extract the theme attributes, if any.
1055        state.mThemeAttrs = a.extractThemeAttrs();
1056
1057        state.mShape = a.getInt(R.styleable.GradientDrawable_shape, state.mShape);
1058        state.mDither = a.getBoolean(R.styleable.GradientDrawable_dither, state.mDither);
1059
1060        if (state.mShape == RING) {
1061            state.mInnerRadius = a.getDimensionPixelSize(
1062                    R.styleable.GradientDrawable_innerRadius, state.mInnerRadius);
1063
1064            if (state.mInnerRadius == -1) {
1065                state.mInnerRadiusRatio = a.getFloat(
1066                        R.styleable.GradientDrawable_innerRadiusRatio, state.mInnerRadiusRatio);
1067            }
1068
1069            state.mThickness = a.getDimensionPixelSize(
1070                    R.styleable.GradientDrawable_thickness, state.mThickness);
1071
1072            if (state.mThickness == -1) {
1073                state.mThicknessRatio = a.getFloat(
1074                        R.styleable.GradientDrawable_thicknessRatio, state.mThicknessRatio);
1075            }
1076
1077            state.mUseLevelForShape = a.getBoolean(
1078                    R.styleable.GradientDrawable_useLevel, state.mUseLevelForShape);
1079        }
1080
1081        final int tintMode = a.getInt(R.styleable.GradientDrawable_tintMode, -1);
1082        if (tintMode != -1) {
1083            state.mTintMode = Drawable.parseTintMode(tintMode, PorterDuff.Mode.SRC_IN);
1084        }
1085
1086        final ColorStateList tint = a.getColorStateList(R.styleable.GradientDrawable_tint);
1087        if (tint != null) {
1088            state.mTint = tint;
1089        }
1090
1091        mTintFilter = updateTintFilter(mTintFilter, state.mTint, state.mTintMode);
1092    }
1093
1094    @Override
1095    public boolean canApplyTheme() {
1096        return (mGradientState != null && mGradientState.canApplyTheme()) || super.canApplyTheme();
1097    }
1098
1099    private void applyThemeChildElements(Theme t) {
1100        final GradientState st = mGradientState;
1101
1102        if (st.mAttrSize != null) {
1103            final TypedArray a = t.resolveAttributes(
1104                    st.mAttrSize, R.styleable.GradientDrawableSize);
1105            updateGradientDrawableSize(a);
1106            a.recycle();
1107        }
1108
1109        if (st.mAttrGradient != null) {
1110            final TypedArray a = t.resolveAttributes(
1111                    st.mAttrGradient, R.styleable.GradientDrawableGradient);
1112            try {
1113                updateGradientDrawableGradient(t.getResources(), a);
1114            } catch (XmlPullParserException e) {
1115                throw new RuntimeException(e);
1116            } finally {
1117                a.recycle();
1118            }
1119        }
1120
1121        if (st.mAttrSolid != null) {
1122            final TypedArray a = t.resolveAttributes(
1123                    st.mAttrSolid, R.styleable.GradientDrawableSolid);
1124            updateGradientDrawableSolid(a);
1125            a.recycle();
1126        }
1127
1128        if (st.mAttrStroke != null) {
1129            final TypedArray a = t.resolveAttributes(
1130                    st.mAttrStroke, R.styleable.GradientDrawableStroke);
1131            updateGradientDrawableStroke(a);
1132            a.recycle();
1133        }
1134
1135        if (st.mAttrCorners != null) {
1136            final TypedArray a = t.resolveAttributes(
1137                    st.mAttrCorners, R.styleable.DrawableCorners);
1138            updateDrawableCorners(a);
1139            a.recycle();
1140        }
1141
1142        if (st.mAttrPadding != null) {
1143            final TypedArray a = t.resolveAttributes(
1144                    st.mAttrPadding, R.styleable.GradientDrawablePadding);
1145            updateGradientDrawablePadding(a);
1146            a.recycle();
1147        }
1148    }
1149
1150    private void inflateChildElements(Resources r, XmlPullParser parser, AttributeSet attrs,
1151            Theme theme) throws XmlPullParserException, IOException {
1152        TypedArray a;
1153        int type;
1154
1155        final int innerDepth = parser.getDepth() + 1;
1156        int depth;
1157        while ((type=parser.next()) != XmlPullParser.END_DOCUMENT
1158               && ((depth=parser.getDepth()) >= innerDepth
1159                       || type != XmlPullParser.END_TAG)) {
1160            if (type != XmlPullParser.START_TAG) {
1161                continue;
1162            }
1163
1164            if (depth > innerDepth) {
1165                continue;
1166            }
1167
1168            String name = parser.getName();
1169
1170            if (name.equals("size")) {
1171                a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawableSize);
1172                updateGradientDrawableSize(a);
1173                a.recycle();
1174            } else if (name.equals("gradient")) {
1175                a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawableGradient);
1176                updateGradientDrawableGradient(r, a);
1177                a.recycle();
1178            } else if (name.equals("solid")) {
1179                a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawableSolid);
1180                updateGradientDrawableSolid(a);
1181                a.recycle();
1182            } else if (name.equals("stroke")) {
1183                a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawableStroke);
1184                updateGradientDrawableStroke(a);
1185                a.recycle();
1186            } else if (name.equals("corners")) {
1187                a = obtainAttributes(r, theme, attrs, R.styleable.DrawableCorners);
1188                updateDrawableCorners(a);
1189                a.recycle();
1190            } else if (name.equals("padding")) {
1191                a = obtainAttributes(r, theme, attrs, R.styleable.GradientDrawablePadding);
1192                updateGradientDrawablePadding(a);
1193                a.recycle();
1194            } else {
1195                Log.w("drawable", "Bad element under <shape>: " + name);
1196            }
1197        }
1198    }
1199
1200    private void updateGradientDrawablePadding(TypedArray a) {
1201        final GradientState st = mGradientState;
1202
1203        // Account for any configuration changes.
1204        st.mChangingConfigurations |= a.getChangingConfigurations();
1205
1206        // Extract the theme attributes, if any.
1207        st.mAttrPadding = a.extractThemeAttrs();
1208
1209        if (st.mPadding == null) {
1210            st.mPadding = new Rect();
1211        }
1212
1213        final Rect pad = st.mPadding;
1214        pad.set(a.getDimensionPixelOffset(R.styleable.GradientDrawablePadding_left, pad.left),
1215                a.getDimensionPixelOffset(R.styleable.GradientDrawablePadding_top, pad.top),
1216                a.getDimensionPixelOffset(R.styleable.GradientDrawablePadding_right, pad.right),
1217                a.getDimensionPixelOffset(R.styleable.GradientDrawablePadding_bottom, pad.bottom));
1218        mPadding = pad;
1219    }
1220
1221    private void updateDrawableCorners(TypedArray a) {
1222        final GradientState st = mGradientState;
1223
1224        // Account for any configuration changes.
1225        st.mChangingConfigurations |= a.getChangingConfigurations();
1226
1227        // Extract the theme attributes, if any.
1228        st.mAttrCorners = a.extractThemeAttrs();
1229
1230        final int radius = a.getDimensionPixelSize(
1231                R.styleable.DrawableCorners_radius, (int) st.mRadius);
1232        setCornerRadius(radius);
1233
1234        // TODO: Update these to be themeable.
1235        final int topLeftRadius = a.getDimensionPixelSize(
1236                R.styleable.DrawableCorners_topLeftRadius, radius);
1237        final int topRightRadius = a.getDimensionPixelSize(
1238                R.styleable.DrawableCorners_topRightRadius, radius);
1239        final int bottomLeftRadius = a.getDimensionPixelSize(
1240                R.styleable.DrawableCorners_bottomLeftRadius, radius);
1241        final int bottomRightRadius = a.getDimensionPixelSize(
1242                R.styleable.DrawableCorners_bottomRightRadius, radius);
1243        if (topLeftRadius != radius || topRightRadius != radius ||
1244                bottomLeftRadius != radius || bottomRightRadius != radius) {
1245            // The corner radii are specified in clockwise order (see Path.addRoundRect())
1246            setCornerRadii(new float[] {
1247                    topLeftRadius, topLeftRadius,
1248                    topRightRadius, topRightRadius,
1249                    bottomRightRadius, bottomRightRadius,
1250                    bottomLeftRadius, bottomLeftRadius
1251            });
1252        }
1253    }
1254
1255    private void updateGradientDrawableStroke(TypedArray a) {
1256        final GradientState st = mGradientState;
1257
1258        // Account for any configuration changes.
1259        st.mChangingConfigurations |= a.getChangingConfigurations();
1260
1261        // Extract the theme attributes, if any.
1262        st.mAttrStroke = a.extractThemeAttrs();
1263
1264        // We have an explicit stroke defined, so the default stroke width
1265        // must be at least 0 or the current stroke width.
1266        final int defaultStrokeWidth = Math.max(0, st.mStrokeWidth);
1267        final int width = a.getDimensionPixelSize(
1268                R.styleable.GradientDrawableStroke_width, defaultStrokeWidth);
1269        final float dashWidth = a.getDimension(
1270                R.styleable.GradientDrawableStroke_dashWidth, st.mStrokeDashWidth);
1271
1272        ColorStateList colorStateList = a.getColorStateList(
1273                R.styleable.GradientDrawableStroke_color);
1274        if (colorStateList == null) {
1275            colorStateList = st.mStrokeColorStateList;
1276        }
1277
1278        if (dashWidth != 0.0f) {
1279            final float dashGap = a.getDimension(
1280                    R.styleable.GradientDrawableStroke_dashGap, st.mStrokeDashGap);
1281            setStroke(width, colorStateList, dashWidth, dashGap);
1282        } else {
1283            setStroke(width, colorStateList);
1284        }
1285    }
1286
1287    private void updateGradientDrawableSolid(TypedArray a) {
1288        final GradientState st = mGradientState;
1289
1290        // Account for any configuration changes.
1291        st.mChangingConfigurations |= a.getChangingConfigurations();
1292
1293        // Extract the theme attributes, if any.
1294        st.mAttrSolid = a.extractThemeAttrs();
1295
1296        final ColorStateList colorStateList = a.getColorStateList(
1297                R.styleable.GradientDrawableSolid_color);
1298        if (colorStateList != null) {
1299            setColor(colorStateList);
1300        }
1301    }
1302
1303    private void updateGradientDrawableGradient(Resources r, TypedArray a)
1304            throws XmlPullParserException {
1305        final GradientState st = mGradientState;
1306
1307        // Account for any configuration changes.
1308        st.mChangingConfigurations |= a.getChangingConfigurations();
1309
1310        // Extract the theme attributes, if any.
1311        st.mAttrGradient = a.extractThemeAttrs();
1312
1313        st.mCenterX = getFloatOrFraction(
1314                a, R.styleable.GradientDrawableGradient_centerX, st.mCenterX);
1315        st.mCenterY = getFloatOrFraction(
1316                a, R.styleable.GradientDrawableGradient_centerY, st.mCenterY);
1317        st.mUseLevel = a.getBoolean(
1318                R.styleable.GradientDrawableGradient_useLevel, st.mUseLevel);
1319        st.mGradient = a.getInt(
1320                R.styleable.GradientDrawableGradient_type, st.mGradient);
1321
1322        // TODO: Update these to be themeable.
1323        final int startColor = a.getColor(
1324                R.styleable.GradientDrawableGradient_startColor, 0);
1325        final boolean hasCenterColor = a.hasValue(
1326                R.styleable.GradientDrawableGradient_centerColor);
1327        final int centerColor = a.getColor(
1328                R.styleable.GradientDrawableGradient_centerColor, 0);
1329        final int endColor = a.getColor(
1330                R.styleable.GradientDrawableGradient_endColor, 0);
1331
1332        if (hasCenterColor) {
1333            st.mColors = new int[3];
1334            st.mColors[0] = startColor;
1335            st.mColors[1] = centerColor;
1336            st.mColors[2] = endColor;
1337
1338            st.mPositions = new float[3];
1339            st.mPositions[0] = 0.0f;
1340            // Since 0.5f is default value, try to take the one that isn't 0.5f
1341            st.mPositions[1] = st.mCenterX != 0.5f ? st.mCenterX : st.mCenterY;
1342            st.mPositions[2] = 1f;
1343        } else {
1344            st.mColors = new int[2];
1345            st.mColors[0] = startColor;
1346            st.mColors[1] = endColor;
1347        }
1348
1349        if (st.mGradient == LINEAR_GRADIENT) {
1350            int angle = (int) a.getFloat(R.styleable.GradientDrawableGradient_angle, st.mAngle);
1351            angle %= 360;
1352
1353            if (angle % 45 != 0) {
1354                throw new XmlPullParserException(a.getPositionDescription()
1355                        + "<gradient> tag requires 'angle' attribute to "
1356                        + "be a multiple of 45");
1357            }
1358
1359            st.mAngle = angle;
1360
1361            switch (angle) {
1362                case 0:
1363                    st.mOrientation = Orientation.LEFT_RIGHT;
1364                    break;
1365                case 45:
1366                    st.mOrientation = Orientation.BL_TR;
1367                    break;
1368                case 90:
1369                    st.mOrientation = Orientation.BOTTOM_TOP;
1370                    break;
1371                case 135:
1372                    st.mOrientation = Orientation.BR_TL;
1373                    break;
1374                case 180:
1375                    st.mOrientation = Orientation.RIGHT_LEFT;
1376                    break;
1377                case 225:
1378                    st.mOrientation = Orientation.TR_BL;
1379                    break;
1380                case 270:
1381                    st.mOrientation = Orientation.TOP_BOTTOM;
1382                    break;
1383                case 315:
1384                    st.mOrientation = Orientation.TL_BR;
1385                    break;
1386            }
1387        } else {
1388            final TypedValue tv = a.peekValue(R.styleable.GradientDrawableGradient_gradientRadius);
1389            if (tv != null) {
1390                final float radius;
1391                final int radiusType;
1392                if (tv.type == TypedValue.TYPE_FRACTION) {
1393                    radius = tv.getFraction(1.0f, 1.0f);
1394
1395                    final int unit = (tv.data >> TypedValue.COMPLEX_UNIT_SHIFT)
1396                            & TypedValue.COMPLEX_UNIT_MASK;
1397                    if (unit == TypedValue.COMPLEX_UNIT_FRACTION_PARENT) {
1398                        radiusType = RADIUS_TYPE_FRACTION_PARENT;
1399                    } else {
1400                        radiusType = RADIUS_TYPE_FRACTION;
1401                    }
1402                } else if (tv.type == TypedValue.TYPE_DIMENSION) {
1403                    radius = tv.getDimension(r.getDisplayMetrics());
1404                    radiusType = RADIUS_TYPE_PIXELS;
1405                } else {
1406                    radius = tv.getFloat();
1407                    radiusType = RADIUS_TYPE_PIXELS;
1408                }
1409
1410                st.mGradientRadius = radius;
1411                st.mGradientRadiusType = radiusType;
1412            } else if (st.mGradient == RADIAL_GRADIENT) {
1413                throw new XmlPullParserException(
1414                        a.getPositionDescription()
1415                        + "<gradient> tag requires 'gradientRadius' "
1416                        + "attribute with radial type");
1417            }
1418        }
1419    }
1420
1421    private void updateGradientDrawableSize(TypedArray a) {
1422        final GradientState st = mGradientState;
1423
1424        // Account for any configuration changes.
1425        st.mChangingConfigurations |= a.getChangingConfigurations();
1426
1427        // Extract the theme attributes, if any.
1428        st.mAttrSize = a.extractThemeAttrs();
1429
1430        st.mWidth = a.getDimensionPixelSize(R.styleable.GradientDrawableSize_width, st.mWidth);
1431        st.mHeight = a.getDimensionPixelSize(R.styleable.GradientDrawableSize_height, st.mHeight);
1432    }
1433
1434    private static float getFloatOrFraction(TypedArray a, int index, float defaultValue) {
1435        TypedValue tv = a.peekValue(index);
1436        float v = defaultValue;
1437        if (tv != null) {
1438            boolean vIsFraction = tv.type == TypedValue.TYPE_FRACTION;
1439            v = vIsFraction ? tv.getFraction(1.0f, 1.0f) : tv.getFloat();
1440        }
1441        return v;
1442    }
1443
1444    @Override
1445    public int getIntrinsicWidth() {
1446        return mGradientState.mWidth;
1447    }
1448
1449    @Override
1450    public int getIntrinsicHeight() {
1451        return mGradientState.mHeight;
1452    }
1453
1454    @Override
1455    public ConstantState getConstantState() {
1456        mGradientState.mChangingConfigurations = getChangingConfigurations();
1457        return mGradientState;
1458    }
1459
1460    private boolean isOpaqueForState() {
1461        if (mGradientState.mStrokeWidth >= 0 && mStrokePaint != null
1462                && !isOpaque(mStrokePaint.getColor())) {
1463            return false;
1464        }
1465
1466        if (!isOpaque(mFillPaint.getColor())) {
1467            return false;
1468        }
1469
1470        return true;
1471    }
1472
1473    @Override
1474    public void getOutline(Outline outline) {
1475        final GradientState st = mGradientState;
1476        final Rect bounds = getBounds();
1477        // only report non-zero alpha if shape being drawn is opaque
1478        outline.setAlpha(st.mOpaqueOverShape && isOpaqueForState() ? (mAlpha / 255.0f) : 0.0f);
1479
1480        switch (st.mShape) {
1481            case RECTANGLE:
1482                if (st.mRadiusArray != null) {
1483                    buildPathIfDirty();
1484                    outline.setConvexPath(mPath);
1485                    return;
1486                }
1487
1488                float rad = 0;
1489                if (st.mRadius > 0.0f) {
1490                    // clamp the radius based on width & height, matching behavior in draw()
1491                    rad = Math.min(st.mRadius,
1492                            Math.min(bounds.width(), bounds.height()) * 0.5f);
1493                }
1494                outline.setRoundRect(bounds, rad);
1495                return;
1496            case OVAL:
1497                outline.setOval(bounds);
1498                return;
1499            case LINE:
1500                // Hairlines (0-width stroke) must have a non-empty outline for
1501                // shadows to draw correctly, so we'll use a very small width.
1502                final float halfStrokeWidth = mStrokePaint == null ?
1503                        0.0001f : mStrokePaint.getStrokeWidth() * 0.5f;
1504                final float centerY = bounds.centerY();
1505                final int top = (int) Math.floor(centerY - halfStrokeWidth);
1506                final int bottom = (int) Math.ceil(centerY + halfStrokeWidth);
1507
1508                outline.setRect(bounds.left, top, bounds.right, bottom);
1509                return;
1510            default:
1511                // TODO: support more complex shapes
1512        }
1513    }
1514
1515    @Override
1516    public Drawable mutate() {
1517        if (!mMutated && super.mutate() == this) {
1518            mGradientState = new GradientState(mGradientState);
1519            initializeWithState(mGradientState);
1520            mMutated = true;
1521        }
1522        return this;
1523    }
1524
1525    /**
1526     * @hide
1527     */
1528    public void clearMutated() {
1529        super.clearMutated();
1530        mMutated = false;
1531    }
1532
1533    final static class GradientState extends ConstantState {
1534        public int mChangingConfigurations;
1535        public int mShape = RECTANGLE;
1536        public int mGradient = LINEAR_GRADIENT;
1537        public int mAngle = 0;
1538        public Orientation mOrientation;
1539        public ColorStateList mColorStateList;
1540        public ColorStateList mStrokeColorStateList;
1541        public int[] mColors;
1542        public int[] mTempColors; // no need to copy
1543        public float[] mTempPositions; // no need to copy
1544        public float[] mPositions;
1545        public int mStrokeWidth = -1; // if >= 0 use stroking.
1546        public float mStrokeDashWidth = 0.0f;
1547        public float mStrokeDashGap = 0.0f;
1548        public float mRadius = 0.0f; // use this if mRadiusArray is null
1549        public float[] mRadiusArray = null;
1550        public Rect mPadding = null;
1551        public int mWidth = -1;
1552        public int mHeight = -1;
1553        public float mInnerRadiusRatio = DEFAULT_INNER_RADIUS_RATIO;
1554        public float mThicknessRatio = DEFAULT_THICKNESS_RATIO;
1555        public int mInnerRadius = -1;
1556        public int mThickness = -1;
1557        public boolean mDither = false;
1558
1559        float mCenterX = 0.5f;
1560        float mCenterY = 0.5f;
1561        float mGradientRadius = 0.5f;
1562        int mGradientRadiusType = RADIUS_TYPE_PIXELS;
1563        boolean mUseLevel = false;
1564        boolean mUseLevelForShape = true;
1565
1566        boolean mOpaqueOverBounds;
1567        boolean mOpaqueOverShape;
1568
1569        ColorStateList mTint = null;
1570        PorterDuff.Mode mTintMode = DEFAULT_TINT_MODE;
1571
1572        int[] mThemeAttrs;
1573        int[] mAttrSize;
1574        int[] mAttrGradient;
1575        int[] mAttrSolid;
1576        int[] mAttrStroke;
1577        int[] mAttrCorners;
1578        int[] mAttrPadding;
1579
1580        GradientState(Orientation orientation, int[] colors) {
1581            mOrientation = orientation;
1582            setColors(colors);
1583        }
1584
1585        public GradientState(GradientState state) {
1586            mChangingConfigurations = state.mChangingConfigurations;
1587            mShape = state.mShape;
1588            mGradient = state.mGradient;
1589            mAngle = state.mAngle;
1590            mOrientation = state.mOrientation;
1591            mColorStateList = state.mColorStateList;
1592            if (state.mColors != null) {
1593                mColors = state.mColors.clone();
1594            }
1595            if (state.mPositions != null) {
1596                mPositions = state.mPositions.clone();
1597            }
1598            mStrokeColorStateList = state.mStrokeColorStateList;
1599            mStrokeWidth = state.mStrokeWidth;
1600            mStrokeDashWidth = state.mStrokeDashWidth;
1601            mStrokeDashGap = state.mStrokeDashGap;
1602            mRadius = state.mRadius;
1603            if (state.mRadiusArray != null) {
1604                mRadiusArray = state.mRadiusArray.clone();
1605            }
1606            if (state.mPadding != null) {
1607                mPadding = new Rect(state.mPadding);
1608            }
1609            mWidth = state.mWidth;
1610            mHeight = state.mHeight;
1611            mInnerRadiusRatio = state.mInnerRadiusRatio;
1612            mThicknessRatio = state.mThicknessRatio;
1613            mInnerRadius = state.mInnerRadius;
1614            mThickness = state.mThickness;
1615            mDither = state.mDither;
1616            mCenterX = state.mCenterX;
1617            mCenterY = state.mCenterY;
1618            mGradientRadius = state.mGradientRadius;
1619            mGradientRadiusType = state.mGradientRadiusType;
1620            mUseLevel = state.mUseLevel;
1621            mUseLevelForShape = state.mUseLevelForShape;
1622            mOpaqueOverBounds = state.mOpaqueOverBounds;
1623            mOpaqueOverShape = state.mOpaqueOverShape;
1624            mTint = state.mTint;
1625            mTintMode = state.mTintMode;
1626            mThemeAttrs = state.mThemeAttrs;
1627            mAttrSize = state.mAttrSize;
1628            mAttrGradient = state.mAttrGradient;
1629            mAttrSolid = state.mAttrSolid;
1630            mAttrStroke = state.mAttrStroke;
1631            mAttrCorners = state.mAttrCorners;
1632            mAttrPadding = state.mAttrPadding;
1633        }
1634
1635        @Override
1636        public boolean canApplyTheme() {
1637            return mThemeAttrs != null || mAttrSize != null || mAttrGradient != null
1638                    || mAttrSolid != null || mAttrStroke != null || mAttrCorners != null
1639                    || mAttrPadding != null || super.canApplyTheme();
1640        }
1641
1642        @Override
1643        public Drawable newDrawable() {
1644            return new GradientDrawable(this);
1645        }
1646
1647        @Override
1648        public Drawable newDrawable(Resources res) {
1649            return new GradientDrawable(this);
1650        }
1651
1652        @Override
1653        public int getChangingConfigurations() {
1654            return mChangingConfigurations;
1655        }
1656
1657        public void setShape(int shape) {
1658            mShape = shape;
1659            computeOpacity();
1660        }
1661
1662        public void setGradientType(int gradient) {
1663            mGradient = gradient;
1664        }
1665
1666        public void setGradientCenter(float x, float y) {
1667            mCenterX = x;
1668            mCenterY = y;
1669        }
1670
1671        public void setColors(int[] colors) {
1672            mColors = colors;
1673            mColorStateList = null;
1674            computeOpacity();
1675        }
1676
1677        public void setColorStateList(ColorStateList colorStateList) {
1678            mColors = null;
1679            mColorStateList = colorStateList;
1680            computeOpacity();
1681        }
1682
1683        private void computeOpacity() {
1684            mOpaqueOverBounds = false;
1685            mOpaqueOverShape = false;
1686
1687            if (mColors != null) {
1688                for (int i = 0; i < mColors.length; i++) {
1689                    if (!isOpaque(mColors[i])) {
1690                        return;
1691                    }
1692                }
1693            }
1694
1695            // An unfilled shape is not opaque over bounds or shape
1696            if (mColors == null && mColorStateList == null) {
1697                return;
1698            }
1699
1700            // Colors are opaque, so opaqueOverShape=true,
1701            mOpaqueOverShape = true;
1702            // and opaqueOverBounds=true if shape fills bounds
1703            mOpaqueOverBounds = mShape == RECTANGLE
1704                    && mRadius <= 0
1705                    && mRadiusArray == null;
1706        }
1707
1708        public void setStroke(
1709                int width, ColorStateList colorStateList, float dashWidth, float dashGap) {
1710            mStrokeWidth = width;
1711            mStrokeColorStateList = colorStateList;
1712            mStrokeDashWidth = dashWidth;
1713            mStrokeDashGap = dashGap;
1714            computeOpacity();
1715        }
1716
1717        public void setCornerRadius(float radius) {
1718            if (radius < 0) {
1719                radius = 0;
1720            }
1721            mRadius = radius;
1722            mRadiusArray = null;
1723        }
1724
1725        public void setCornerRadii(float[] radii) {
1726            mRadiusArray = radii;
1727            if (radii == null) {
1728                mRadius = 0;
1729            }
1730        }
1731
1732        public void setSize(int width, int height) {
1733            mWidth = width;
1734            mHeight = height;
1735        }
1736
1737        public void setGradientRadius(float gradientRadius, int type) {
1738            mGradientRadius = gradientRadius;
1739            mGradientRadiusType = type;
1740        }
1741    }
1742
1743    static boolean isOpaque(int color) {
1744        return ((color >> 24) & 0xff) == 0xff;
1745    }
1746
1747    /**
1748     * Creates a new themed GradientDrawable based on the specified constant state.
1749     * <p>
1750     * The resulting drawable is guaranteed to have a new constant state.
1751     *
1752     * @param state Constant state from which the drawable inherits
1753     */
1754    private GradientDrawable(GradientState state) {
1755        mGradientState = state;
1756
1757        initializeWithState(mGradientState);
1758
1759        mGradientIsDirty = true;
1760        mMutated = false;
1761    }
1762
1763    private void initializeWithState(GradientState state) {
1764        if (state.mColorStateList != null) {
1765            final int[] currentState = getState();
1766            final int stateColor = state.mColorStateList.getColorForState(currentState, 0);
1767            mFillPaint.setColor(stateColor);
1768        } else if (state.mColors == null) {
1769            // If we don't have a solid color and we don't have a gradient,
1770            // the app is stroking the shape, set the color to the default
1771            // value of state.mSolidColor
1772            mFillPaint.setColor(0);
1773        } else {
1774            // Otherwise, make sure the fill alpha is maxed out.
1775            mFillPaint.setColor(Color.BLACK);
1776        }
1777
1778        mPadding = state.mPadding;
1779
1780        if (state.mStrokeWidth >= 0) {
1781            mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
1782            mStrokePaint.setStyle(Paint.Style.STROKE);
1783            mStrokePaint.setStrokeWidth(state.mStrokeWidth);
1784
1785            if (state.mStrokeColorStateList != null) {
1786                final int[] currentState = getState();
1787                final int strokeStateColor = state.mStrokeColorStateList.getColorForState(
1788                        currentState, 0);
1789                mStrokePaint.setColor(strokeStateColor);
1790            }
1791
1792            if (state.mStrokeDashWidth != 0.0f) {
1793                final DashPathEffect e = new DashPathEffect(
1794                        new float[] { state.mStrokeDashWidth, state.mStrokeDashGap }, 0);
1795                mStrokePaint.setPathEffect(e);
1796            }
1797        }
1798
1799        mTintFilter = updateTintFilter(mTintFilter, state.mTint, state.mTintMode);
1800    }
1801}
1802