src/com/android/bitmap/drawable/StyledCornersBitmapDrawable.java - platform/frameworks/opt/bitmap - Git at Google

 /*
  * Copyright (C) 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.bitmap.drawable;

 import android.content.res.Resources;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.Paint.Style;
 import android.graphics.Path;
 import android.graphics.Rect;
 import android.graphics.RectF;
 import android.util.Log;
 import android.view.View;

 import com.android.bitmap.BitmapCache;

 /**
  * A custom ExtendedBitmapDrawable that styles the corners in configurable ways.
  *
  * All four corners can be configured as {@link #CORNER_STYLE_SHARP},
  * {@link #CORNER_STYLE_ROUND}, or {@link #CORNER_STYLE_FLAP}.
  * This is accomplished applying a non-rectangular clip applied to the canvas.
  *
  * A border is draw that conforms to the styled corners.
  *
  * {@link #CORNER_STYLE_FLAP} corners have a colored flap drawn within the bounds.
  */
 public class StyledCornersBitmapDrawable extends ExtendedBitmapDrawable {
     private static final String TAG = StyledCornersBitmapDrawable.class.getSimpleName();

     public static final int CORNER_STYLE_SHARP = 0;
     public static final int CORNER_STYLE_ROUND = 1;
     public static final int CORNER_STYLE_FLAP = 2;

     private static final int START_RIGHT = 0;
     private static final int START_BOTTOM = 90;
     private static final int START_LEFT = 180;
     private static final int START_TOP = 270;
     private static final int QUARTER_CIRCLE = 90;
     private static final RectF sRectF = new RectF();

     private final Paint mFlapPaint = new Paint();
     private final Paint mBorderPaint = new Paint();
     private final Paint mCompatibilityModeBackgroundPaint = new Paint();
     private final Path mClipPath = new Path();
     private final Path mCompatibilityModePath = new Path();
     private final float mCornerRoundRadius;
     private final float mCornerFlapSide;

     private int mTopLeftCornerStyle = CORNER_STYLE_SHARP;
     private int mTopRightCornerStyle = CORNER_STYLE_SHARP;
     private int mBottomRightCornerStyle = CORNER_STYLE_SHARP;
     private int mBottomLeftCornerStyle = CORNER_STYLE_SHARP;

     private int mTopStartCornerStyle = CORNER_STYLE_SHARP;
     private int mTopEndCornerStyle = CORNER_STYLE_SHARP;
     private int mBottomEndCornerStyle = CORNER_STYLE_SHARP;
     private int mBottomStartCornerStyle = CORNER_STYLE_SHARP;

     private int mScrimColor;
     private float mBorderWidth;
     private boolean mIsCompatibilityMode;
     private boolean mEatInvalidates;

     /**
      * Create a new StyledCornersBitmapDrawable.
      */
     public StyledCornersBitmapDrawable(Resources res, BitmapCache cache,
             boolean limitDensity, ExtendedOptions opts, float cornerRoundRadius,
             float cornerFlapSide) {
         super(res, cache, limitDensity, opts);

         mCornerRoundRadius = cornerRoundRadius;
         mCornerFlapSide = cornerFlapSide;

         mFlapPaint.setColor(Color.TRANSPARENT);
         mFlapPaint.setStyle(Style.FILL);
         mFlapPaint.setAntiAlias(true);

         mBorderPaint.setColor(Color.TRANSPARENT);
         mBorderPaint.setStyle(Style.STROKE);
         mBorderPaint.setStrokeWidth(mBorderWidth);
         mBorderPaint.setAntiAlias(true);

         mCompatibilityModeBackgroundPaint.setColor(Color.TRANSPARENT);
         mCompatibilityModeBackgroundPaint.setStyle(Style.FILL);
         mCompatibilityModeBackgroundPaint.setAntiAlias(true);

         mScrimColor = Color.TRANSPARENT;
     }

     /**
      * Set the border stroke width of this drawable.
      */
     public void setBorderWidth(final float borderWidth) {
         final boolean changed = mBorderPaint.getStrokeWidth() != borderWidth;
         mBorderPaint.setStrokeWidth(borderWidth);
         mBorderWidth = borderWidth;

         if (changed) {
             invalidateSelf();
         }
     }

     /**
      * Set the border stroke color of this drawable. Set to {@link Color#TRANSPARENT} to disable.
      */
     public void setBorderColor(final int color) {
         final boolean changed = mBorderPaint.getColor() != color;
         mBorderPaint.setColor(color);

         if (changed) {
             invalidateSelf();
         }
     }

     /** Set the corner styles for all four corners specified in RTL friendly ways */
     public void setCornerStylesRelative(int topStart, int topEnd, int bottomEnd, int bottomStart) {
         mTopStartCornerStyle = topStart;
         mTopEndCornerStyle = topEnd;
         mBottomEndCornerStyle = bottomEnd;
         mBottomStartCornerStyle = bottomStart;
         resolveCornerStyles();
     }

     @Override
     public void onLayoutDirectionChangeLocal(int layoutDirection) {
         resolveCornerStyles();
     }

     /**
      * Get the flap color for all corners that have style {@link #CORNER_STYLE_SHARP}.
      */
     public int getFlapColor() {
         return mFlapPaint.getColor();
     }

     /**
      * Set the flap color for all corners that have style {@link #CORNER_STYLE_SHARP}.
      *
      * Use {@link android.graphics.Color#TRANSPARENT} to disable flap colors.
      */
     public void setFlapColor(int flapColor) {
         boolean changed = mFlapPaint.getColor() != flapColor;
         mFlapPaint.setColor(flapColor);

         if (changed) {
             invalidateSelf();
         }
     }

     /**
      * Get the color of the scrim that is drawn over the contents, but under the flaps and borders.
      */
     public int getScrimColor() {
         return mScrimColor;
     }

     /**
      * Set the color of the scrim that is drawn over the contents, but under the flaps and borders.
      *
      * Use {@link android.graphics.Color#TRANSPARENT} to disable the scrim.
      */
     public void setScrimColor(int color) {
         boolean changed = mScrimColor != color;
         mScrimColor = color;

         if (changed) {
             invalidateSelf();
         }
     }

     /**
      * Sets whether we should work around an issue introduced in Android 4.4.3,
      * where a WebView can corrupt the stencil buffer of the canvas when the canvas is clipped
      * using a non-rectangular Path.
      */
     public void setCompatibilityMode(boolean isCompatibilityMode) {
         boolean changed = mIsCompatibilityMode != isCompatibilityMode;
         mIsCompatibilityMode = isCompatibilityMode;

         if (changed) {
             invalidateSelf();
         }
     }

     /**
      * Sets the color of the container that this drawable is in. The given color will be used in
      * {@link #setCompatibilityMode compatibility mode} to draw fake corners to emulate clipped
      * corners.
      */
     public void setCompatibilityModeBackgroundColor(int color) {
         boolean changed = mCompatibilityModeBackgroundPaint.getColor() != color;
         mCompatibilityModeBackgroundPaint.setColor(color);

         if (changed) {
             invalidateSelf();
         }
     }

     @Override
     protected void onBoundsChange(Rect bounds) {
         super.onBoundsChange(bounds);

         recalculatePath();
     }

     /**
      * Override draw(android.graphics.Canvas) instead of
      * {@link #onDraw(android.graphics.Canvas)} to clip all the drawable layers.
      */
     @Override
     public void draw(Canvas canvas) {
         final Rect bounds = getBounds();
         if (bounds.isEmpty()) {
             return;
         }

         pauseInvalidate();

         // Clip to path.
         if (!mIsCompatibilityMode) {
             canvas.save();
             canvas.clipPath(mClipPath);
         }

         // Draw parent within path.
         super.draw(canvas);

         // Draw scrim on top of parent.
         canvas.drawColor(mScrimColor);

         // Draw flaps.
         float left = bounds.left + mBorderWidth / 2;
         float top = bounds.top + mBorderWidth / 2;
         float right = bounds.right - mBorderWidth / 2;
         float bottom = bounds.bottom - mBorderWidth / 2;
         RectF flapCornerRectF = sRectF;
         flapCornerRectF.set(0, 0, mCornerFlapSide + mCornerRoundRadius,
                 mCornerFlapSide + mCornerRoundRadius);

         if (mTopLeftCornerStyle == CORNER_STYLE_FLAP) {
             flapCornerRectF.offsetTo(left, top);
             canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
                     mCornerRoundRadius, mFlapPaint);
         }
         if (mTopRightCornerStyle == CORNER_STYLE_FLAP) {
             flapCornerRectF.offsetTo(right - mCornerFlapSide, top);
             canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
                     mCornerRoundRadius, mFlapPaint);
         }
         if (mBottomRightCornerStyle == CORNER_STYLE_FLAP) {
             flapCornerRectF.offsetTo(right - mCornerFlapSide, bottom - mCornerFlapSide);
             canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
                     mCornerRoundRadius, mFlapPaint);
         }
         if (mBottomLeftCornerStyle == CORNER_STYLE_FLAP) {
             flapCornerRectF.offsetTo(left, bottom - mCornerFlapSide);
             canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
                     mCornerRoundRadius, mFlapPaint);
         }

         if (!mIsCompatibilityMode) {
             canvas.restore();
         }

         if (mIsCompatibilityMode) {
             drawFakeCornersForCompatibilityMode(canvas);
         }

         // Draw border around path.
         canvas.drawPath(mClipPath, mBorderPaint);

         resumeInvalidate();
     }

     @Override
     public void invalidateSelf() {
         if (!mEatInvalidates) {
             super.invalidateSelf();
         } else {
             Log.d(TAG, "Skipping invalidate.");
         }
     }

     protected void drawFakeCornersForCompatibilityMode(final Canvas canvas) {
         final Rect bounds = getBounds();

         float left = bounds.left;
         float top = bounds.top;
         float right = bounds.right;
         float bottom = bounds.bottom;

         // Draw fake round corners.
         RectF fakeCornerRectF = sRectF;
         fakeCornerRectF.set(0, 0, mCornerRoundRadius * 2, mCornerRoundRadius * 2);
         if (mTopLeftCornerStyle == CORNER_STYLE_ROUND) {
             fakeCornerRectF.offsetTo(left, top);
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(left, top);
             mCompatibilityModePath.lineTo(left + mCornerRoundRadius, top);
             mCompatibilityModePath.arcTo(fakeCornerRectF, START_TOP, -QUARTER_CIRCLE);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mTopRightCornerStyle == CORNER_STYLE_ROUND) {
             fakeCornerRectF.offsetTo(right - fakeCornerRectF.width(), top);
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(right, top);
             mCompatibilityModePath.lineTo(right, top + mCornerRoundRadius);
             mCompatibilityModePath.arcTo(fakeCornerRectF, START_RIGHT, -QUARTER_CIRCLE);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mBottomRightCornerStyle == CORNER_STYLE_ROUND) {
             fakeCornerRectF
                     .offsetTo(right - fakeCornerRectF.width(), bottom - fakeCornerRectF.height());
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(right, bottom);
             mCompatibilityModePath.lineTo(right - mCornerRoundRadius, bottom);
             mCompatibilityModePath.arcTo(fakeCornerRectF, START_BOTTOM, -QUARTER_CIRCLE);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mBottomLeftCornerStyle == CORNER_STYLE_ROUND) {
             fakeCornerRectF.offsetTo(left, bottom - fakeCornerRectF.height());
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(left, bottom);
             mCompatibilityModePath.lineTo(left, bottom - mCornerRoundRadius);
             mCompatibilityModePath.arcTo(fakeCornerRectF, START_LEFT, -QUARTER_CIRCLE);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }

         // Draw fake flap corners.
         if (mTopLeftCornerStyle == CORNER_STYLE_FLAP) {
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(left, top);
             mCompatibilityModePath.lineTo(left + mCornerFlapSide, top);
             mCompatibilityModePath.lineTo(left, top + mCornerFlapSide);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mTopRightCornerStyle == CORNER_STYLE_FLAP) {
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(right, top);
             mCompatibilityModePath.lineTo(right, top + mCornerFlapSide);
             mCompatibilityModePath.lineTo(right - mCornerFlapSide, top);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mBottomRightCornerStyle == CORNER_STYLE_FLAP) {
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(right, bottom);
             mCompatibilityModePath.lineTo(right - mCornerFlapSide, bottom);
             mCompatibilityModePath.lineTo(right, bottom - mCornerFlapSide);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
         if (mBottomLeftCornerStyle == CORNER_STYLE_FLAP) {
             mCompatibilityModePath.rewind();
             mCompatibilityModePath.moveTo(left, bottom);
             mCompatibilityModePath.lineTo(left, bottom - mCornerFlapSide);
             mCompatibilityModePath.lineTo(left + mCornerFlapSide, bottom);
             mCompatibilityModePath.close();
             canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
         }
     }

     private void pauseInvalidate() {
         mEatInvalidates = true;
     }

     private void resumeInvalidate() {
         mEatInvalidates = false;
     }

     private void recalculatePath() {
         Rect bounds = getBounds();

         if (bounds.isEmpty()) {
             return;
         }

         // Setup.
         float left = bounds.left + mBorderWidth / 2;
         float top = bounds.top + mBorderWidth / 2;
         float right = bounds.right - mBorderWidth / 2;
         float bottom = bounds.bottom - mBorderWidth / 2;
         RectF roundedCornerRectF = sRectF;
         roundedCornerRectF.set(0, 0, 2 * mCornerRoundRadius, 2 * mCornerRoundRadius);
         mClipPath.rewind();

         switch (mTopLeftCornerStyle) {
             case CORNER_STYLE_SHARP:
                 mClipPath.moveTo(left, top);
                 break;
             case CORNER_STYLE_ROUND:
                 roundedCornerRectF.offsetTo(left, top);
                 mClipPath.arcTo(roundedCornerRectF, START_LEFT, QUARTER_CIRCLE);
                 break;
             case CORNER_STYLE_FLAP:
                 mClipPath.moveTo(left, top - mCornerFlapSide);
                 mClipPath.lineTo(left + mCornerFlapSide, top);
                 break;
         }

         switch (mTopRightCornerStyle) {
             case CORNER_STYLE_SHARP:
                 mClipPath.lineTo(right, top);
                 break;
             case CORNER_STYLE_ROUND:
                 roundedCornerRectF.offsetTo(right - roundedCornerRectF.width(), top);
                 mClipPath.arcTo(roundedCornerRectF, START_TOP, QUARTER_CIRCLE);
                 break;
             case CORNER_STYLE_FLAP:
                 mClipPath.lineTo(right - mCornerFlapSide, top);
                 mClipPath.lineTo(right, top + mCornerFlapSide);
                 break;
         }

         switch (mBottomRightCornerStyle) {
             case CORNER_STYLE_SHARP:
                 mClipPath.lineTo(right, bottom);
                 break;
             case CORNER_STYLE_ROUND:
                 roundedCornerRectF.offsetTo(right - roundedCornerRectF.width(),
                         bottom - roundedCornerRectF.height());
                 mClipPath.arcTo(roundedCornerRectF, START_RIGHT, QUARTER_CIRCLE);
                 break;
             case CORNER_STYLE_FLAP:
                 mClipPath.lineTo(right, bottom - mCornerFlapSide);
                 mClipPath.lineTo(right - mCornerFlapSide, bottom);
                 break;
         }

         switch (mBottomLeftCornerStyle) {
             case CORNER_STYLE_SHARP:
                 mClipPath.lineTo(left, bottom);
                 break;
             case CORNER_STYLE_ROUND:
                 roundedCornerRectF.offsetTo(left, bottom - roundedCornerRectF.height());
                 mClipPath.arcTo(roundedCornerRectF, START_BOTTOM, QUARTER_CIRCLE);
                 break;
             case CORNER_STYLE_FLAP:
                 mClipPath.lineTo(left + mCornerFlapSide, bottom);
                 mClipPath.lineTo(left, bottom - mCornerFlapSide);
                 break;
         }

         // Finish.
         mClipPath.close();
     }

     private void resolveCornerStyles() {
         boolean isLtr = getLayoutDirectionLocal() == View.LAYOUT_DIRECTION_LTR;
         setCornerStyles(
             isLtr ? mTopStartCornerStyle : mTopEndCornerStyle,
             isLtr ? mTopEndCornerStyle : mTopStartCornerStyle,
             isLtr ? mBottomEndCornerStyle : mBottomStartCornerStyle,
             isLtr ? mBottomStartCornerStyle : mBottomEndCornerStyle);
     }

     /** Set the corner styles for all four corners */
     private void setCornerStyles(int topLeft, int topRight, int bottomRight, int bottomLeft) {
         boolean changed = mTopLeftCornerStyle != topLeft
             || mTopRightCornerStyle != topRight
             || mBottomRightCornerStyle != bottomRight
             || mBottomLeftCornerStyle != bottomLeft;

         mTopLeftCornerStyle = topLeft;
         mTopRightCornerStyle = topRight;
         mBottomRightCornerStyle = bottomRight;
         mBottomLeftCornerStyle = bottomLeft;

         if (changed) {
             recalculatePath();
         }
     }
 }
	/*
	* Copyright (C) 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.bitmap.drawable;

	import android.content.res.Resources;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Paint;
	import android.graphics.Paint.Style;
	import android.graphics.Path;
	import android.graphics.Rect;
	import android.graphics.RectF;
	import android.util.Log;
	import android.view.View;

	import com.android.bitmap.BitmapCache;

	/**
	* A custom ExtendedBitmapDrawable that styles the corners in configurable ways.
	*
	* All four corners can be configured as {@link #CORNER_STYLE_SHARP},
	* {@link #CORNER_STYLE_ROUND}, or {@link #CORNER_STYLE_FLAP}.
	* This is accomplished applying a non-rectangular clip applied to the canvas.
	*
	* A border is draw that conforms to the styled corners.
	*
	* {@link #CORNER_STYLE_FLAP} corners have a colored flap drawn within the bounds.
	*/
	public class StyledCornersBitmapDrawable extends ExtendedBitmapDrawable {
	private static final String TAG = StyledCornersBitmapDrawable.class.getSimpleName();

	public static final int CORNER_STYLE_SHARP = 0;
	public static final int CORNER_STYLE_ROUND = 1;
	public static final int CORNER_STYLE_FLAP = 2;

	private static final int START_RIGHT = 0;
	private static final int START_BOTTOM = 90;
	private static final int START_LEFT = 180;
	private static final int START_TOP = 270;
	private static final int QUARTER_CIRCLE = 90;
	private static final RectF sRectF = new RectF();

	private final Paint mFlapPaint = new Paint();
	private final Paint mBorderPaint = new Paint();
	private final Paint mCompatibilityModeBackgroundPaint = new Paint();
	private final Path mClipPath = new Path();
	private final Path mCompatibilityModePath = new Path();
	private final float mCornerRoundRadius;
	private final float mCornerFlapSide;

	private int mTopLeftCornerStyle = CORNER_STYLE_SHARP;
	private int mTopRightCornerStyle = CORNER_STYLE_SHARP;
	private int mBottomRightCornerStyle = CORNER_STYLE_SHARP;
	private int mBottomLeftCornerStyle = CORNER_STYLE_SHARP;

	private int mTopStartCornerStyle = CORNER_STYLE_SHARP;
	private int mTopEndCornerStyle = CORNER_STYLE_SHARP;
	private int mBottomEndCornerStyle = CORNER_STYLE_SHARP;
	private int mBottomStartCornerStyle = CORNER_STYLE_SHARP;

	private int mScrimColor;
	private float mBorderWidth;
	private boolean mIsCompatibilityMode;
	private boolean mEatInvalidates;

	/**
	* Create a new StyledCornersBitmapDrawable.
	*/
	public StyledCornersBitmapDrawable(Resources res, BitmapCache cache,
	boolean limitDensity, ExtendedOptions opts, float cornerRoundRadius,
	float cornerFlapSide) {
	super(res, cache, limitDensity, opts);

	mCornerRoundRadius = cornerRoundRadius;
	mCornerFlapSide = cornerFlapSide;

	mFlapPaint.setColor(Color.TRANSPARENT);
	mFlapPaint.setStyle(Style.FILL);
	mFlapPaint.setAntiAlias(true);

	mBorderPaint.setColor(Color.TRANSPARENT);
	mBorderPaint.setStyle(Style.STROKE);
	mBorderPaint.setStrokeWidth(mBorderWidth);
	mBorderPaint.setAntiAlias(true);

	mCompatibilityModeBackgroundPaint.setColor(Color.TRANSPARENT);
	mCompatibilityModeBackgroundPaint.setStyle(Style.FILL);
	mCompatibilityModeBackgroundPaint.setAntiAlias(true);

	mScrimColor = Color.TRANSPARENT;
	}

	/**
	* Set the border stroke width of this drawable.
	*/
	public void setBorderWidth(final float borderWidth) {
	final boolean changed = mBorderPaint.getStrokeWidth() != borderWidth;
	mBorderPaint.setStrokeWidth(borderWidth);
	mBorderWidth = borderWidth;

	if (changed) {
	invalidateSelf();
	}
	}

	/**
	* Set the border stroke color of this drawable. Set to {@link Color#TRANSPARENT} to disable.
	*/
	public void setBorderColor(final int color) {
	final boolean changed = mBorderPaint.getColor() != color;
	mBorderPaint.setColor(color);

	if (changed) {
	invalidateSelf();
	}
	}

	/** Set the corner styles for all four corners specified in RTL friendly ways */
	public void setCornerStylesRelative(int topStart, int topEnd, int bottomEnd, int bottomStart) {
	mTopStartCornerStyle = topStart;
	mTopEndCornerStyle = topEnd;
	mBottomEndCornerStyle = bottomEnd;
	mBottomStartCornerStyle = bottomStart;
	resolveCornerStyles();
	}

	@Override
	public void onLayoutDirectionChangeLocal(int layoutDirection) {
	resolveCornerStyles();
	}

	/**
	* Get the flap color for all corners that have style {@link #CORNER_STYLE_SHARP}.
	*/
	public int getFlapColor() {
	return mFlapPaint.getColor();
	}

	/**
	* Set the flap color for all corners that have style {@link #CORNER_STYLE_SHARP}.
	*
	* Use {@link android.graphics.Color#TRANSPARENT} to disable flap colors.
	*/
	public void setFlapColor(int flapColor) {
	boolean changed = mFlapPaint.getColor() != flapColor;
	mFlapPaint.setColor(flapColor);

	if (changed) {
	invalidateSelf();
	}
	}

	/**
	* Get the color of the scrim that is drawn over the contents, but under the flaps and borders.
	*/
	public int getScrimColor() {
	return mScrimColor;
	}

	/**
	* Set the color of the scrim that is drawn over the contents, but under the flaps and borders.
	*
	* Use {@link android.graphics.Color#TRANSPARENT} to disable the scrim.
	*/
	public void setScrimColor(int color) {
	boolean changed = mScrimColor != color;
	mScrimColor = color;

	if (changed) {
	invalidateSelf();
	}
	}

	/**
	* Sets whether we should work around an issue introduced in Android 4.4.3,
	* where a WebView can corrupt the stencil buffer of the canvas when the canvas is clipped
	* using a non-rectangular Path.
	*/
	public void setCompatibilityMode(boolean isCompatibilityMode) {
	boolean changed = mIsCompatibilityMode != isCompatibilityMode;
	mIsCompatibilityMode = isCompatibilityMode;

	if (changed) {
	invalidateSelf();
	}
	}

	/**
	* Sets the color of the container that this drawable is in. The given color will be used in
	* {@link #setCompatibilityMode compatibility mode} to draw fake corners to emulate clipped
	* corners.
	*/
	public void setCompatibilityModeBackgroundColor(int color) {
	boolean changed = mCompatibilityModeBackgroundPaint.getColor() != color;
	mCompatibilityModeBackgroundPaint.setColor(color);

	if (changed) {
	invalidateSelf();
	}
	}

	@Override
	protected void onBoundsChange(Rect bounds) {
	super.onBoundsChange(bounds);

	recalculatePath();
	}

	/**
	* Override draw(android.graphics.Canvas) instead of
	* {@link #onDraw(android.graphics.Canvas)} to clip all the drawable layers.
	*/
	@Override
	public void draw(Canvas canvas) {
	final Rect bounds = getBounds();
	if (bounds.isEmpty()) {
	return;
	}

	pauseInvalidate();

	// Clip to path.
	if (!mIsCompatibilityMode) {
	canvas.save();
	canvas.clipPath(mClipPath);
	}

	// Draw parent within path.
	super.draw(canvas);

	// Draw scrim on top of parent.
	canvas.drawColor(mScrimColor);

	// Draw flaps.
	float left = bounds.left + mBorderWidth / 2;
	float top = bounds.top + mBorderWidth / 2;
	float right = bounds.right - mBorderWidth / 2;
	float bottom = bounds.bottom - mBorderWidth / 2;
	RectF flapCornerRectF = sRectF;
	flapCornerRectF.set(0, 0, mCornerFlapSide + mCornerRoundRadius,
	mCornerFlapSide + mCornerRoundRadius);

	if (mTopLeftCornerStyle == CORNER_STYLE_FLAP) {
	flapCornerRectF.offsetTo(left, top);
	canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
	mCornerRoundRadius, mFlapPaint);
	}
	if (mTopRightCornerStyle == CORNER_STYLE_FLAP) {
	flapCornerRectF.offsetTo(right - mCornerFlapSide, top);
	canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
	mCornerRoundRadius, mFlapPaint);
	}
	if (mBottomRightCornerStyle == CORNER_STYLE_FLAP) {
	flapCornerRectF.offsetTo(right - mCornerFlapSide, bottom - mCornerFlapSide);
	canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
	mCornerRoundRadius, mFlapPaint);
	}
	if (mBottomLeftCornerStyle == CORNER_STYLE_FLAP) {
	flapCornerRectF.offsetTo(left, bottom - mCornerFlapSide);
	canvas.drawRoundRect(flapCornerRectF, mCornerRoundRadius,
	mCornerRoundRadius, mFlapPaint);
	}

	if (!mIsCompatibilityMode) {
	canvas.restore();
	}

	if (mIsCompatibilityMode) {
	drawFakeCornersForCompatibilityMode(canvas);
	}

	// Draw border around path.
	canvas.drawPath(mClipPath, mBorderPaint);

	resumeInvalidate();
	}

	@Override
	public void invalidateSelf() {
	if (!mEatInvalidates) {
	super.invalidateSelf();
	} else {
	Log.d(TAG, "Skipping invalidate.");
	}
	}

	protected void drawFakeCornersForCompatibilityMode(final Canvas canvas) {
	final Rect bounds = getBounds();

	float left = bounds.left;
	float top = bounds.top;
	float right = bounds.right;
	float bottom = bounds.bottom;

	// Draw fake round corners.
	RectF fakeCornerRectF = sRectF;
	fakeCornerRectF.set(0, 0, mCornerRoundRadius * 2, mCornerRoundRadius * 2);
	if (mTopLeftCornerStyle == CORNER_STYLE_ROUND) {
	fakeCornerRectF.offsetTo(left, top);
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(left, top);
	mCompatibilityModePath.lineTo(left + mCornerRoundRadius, top);
	mCompatibilityModePath.arcTo(fakeCornerRectF, START_TOP, -QUARTER_CIRCLE);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mTopRightCornerStyle == CORNER_STYLE_ROUND) {
	fakeCornerRectF.offsetTo(right - fakeCornerRectF.width(), top);
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(right, top);
	mCompatibilityModePath.lineTo(right, top + mCornerRoundRadius);
	mCompatibilityModePath.arcTo(fakeCornerRectF, START_RIGHT, -QUARTER_CIRCLE);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mBottomRightCornerStyle == CORNER_STYLE_ROUND) {
	fakeCornerRectF
	.offsetTo(right - fakeCornerRectF.width(), bottom - fakeCornerRectF.height());
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(right, bottom);
	mCompatibilityModePath.lineTo(right - mCornerRoundRadius, bottom);
	mCompatibilityModePath.arcTo(fakeCornerRectF, START_BOTTOM, -QUARTER_CIRCLE);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mBottomLeftCornerStyle == CORNER_STYLE_ROUND) {
	fakeCornerRectF.offsetTo(left, bottom - fakeCornerRectF.height());
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(left, bottom);
	mCompatibilityModePath.lineTo(left, bottom - mCornerRoundRadius);
	mCompatibilityModePath.arcTo(fakeCornerRectF, START_LEFT, -QUARTER_CIRCLE);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}

	// Draw fake flap corners.
	if (mTopLeftCornerStyle == CORNER_STYLE_FLAP) {
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(left, top);
	mCompatibilityModePath.lineTo(left + mCornerFlapSide, top);
	mCompatibilityModePath.lineTo(left, top + mCornerFlapSide);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mTopRightCornerStyle == CORNER_STYLE_FLAP) {
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(right, top);
	mCompatibilityModePath.lineTo(right, top + mCornerFlapSide);
	mCompatibilityModePath.lineTo(right - mCornerFlapSide, top);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mBottomRightCornerStyle == CORNER_STYLE_FLAP) {
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(right, bottom);
	mCompatibilityModePath.lineTo(right - mCornerFlapSide, bottom);
	mCompatibilityModePath.lineTo(right, bottom - mCornerFlapSide);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	if (mBottomLeftCornerStyle == CORNER_STYLE_FLAP) {
	mCompatibilityModePath.rewind();
	mCompatibilityModePath.moveTo(left, bottom);
	mCompatibilityModePath.lineTo(left, bottom - mCornerFlapSide);
	mCompatibilityModePath.lineTo(left + mCornerFlapSide, bottom);
	mCompatibilityModePath.close();
	canvas.drawPath(mCompatibilityModePath, mCompatibilityModeBackgroundPaint);
	}
	}

	private void pauseInvalidate() {
	mEatInvalidates = true;
	}

	private void resumeInvalidate() {
	mEatInvalidates = false;
	}

	private void recalculatePath() {
	Rect bounds = getBounds();

	if (bounds.isEmpty()) {
	return;
	}

	// Setup.
	float left = bounds.left + mBorderWidth / 2;
	float top = bounds.top + mBorderWidth / 2;
	float right = bounds.right - mBorderWidth / 2;
	float bottom = bounds.bottom - mBorderWidth / 2;
	RectF roundedCornerRectF = sRectF;
	roundedCornerRectF.set(0, 0, 2 * mCornerRoundRadius, 2 * mCornerRoundRadius);
	mClipPath.rewind();

	switch (mTopLeftCornerStyle) {
	case CORNER_STYLE_SHARP:
	mClipPath.moveTo(left, top);
	break;
	case CORNER_STYLE_ROUND:
	roundedCornerRectF.offsetTo(left, top);
	mClipPath.arcTo(roundedCornerRectF, START_LEFT, QUARTER_CIRCLE);
	break;
	case CORNER_STYLE_FLAP:
	mClipPath.moveTo(left, top - mCornerFlapSide);
	mClipPath.lineTo(left + mCornerFlapSide, top);
	break;
	}

	switch (mTopRightCornerStyle) {
	case CORNER_STYLE_SHARP:
	mClipPath.lineTo(right, top);
	break;
	case CORNER_STYLE_ROUND:
	roundedCornerRectF.offsetTo(right - roundedCornerRectF.width(), top);
	mClipPath.arcTo(roundedCornerRectF, START_TOP, QUARTER_CIRCLE);
	break;
	case CORNER_STYLE_FLAP:
	mClipPath.lineTo(right - mCornerFlapSide, top);
	mClipPath.lineTo(right, top + mCornerFlapSide);
	break;
	}

	switch (mBottomRightCornerStyle) {
	case CORNER_STYLE_SHARP:
	mClipPath.lineTo(right, bottom);
	break;
	case CORNER_STYLE_ROUND:
	roundedCornerRectF.offsetTo(right - roundedCornerRectF.width(),
	bottom - roundedCornerRectF.height());
	mClipPath.arcTo(roundedCornerRectF, START_RIGHT, QUARTER_CIRCLE);
	break;
	case CORNER_STYLE_FLAP:
	mClipPath.lineTo(right, bottom - mCornerFlapSide);
	mClipPath.lineTo(right - mCornerFlapSide, bottom);
	break;
	}

	switch (mBottomLeftCornerStyle) {
	case CORNER_STYLE_SHARP:
	mClipPath.lineTo(left, bottom);
	break;
	case CORNER_STYLE_ROUND:
	roundedCornerRectF.offsetTo(left, bottom - roundedCornerRectF.height());
	mClipPath.arcTo(roundedCornerRectF, START_BOTTOM, QUARTER_CIRCLE);
	break;
	case CORNER_STYLE_FLAP:
	mClipPath.lineTo(left + mCornerFlapSide, bottom);
	mClipPath.lineTo(left, bottom - mCornerFlapSide);
	break;
	}

	// Finish.
	mClipPath.close();
	}

	private void resolveCornerStyles() {
	boolean isLtr = getLayoutDirectionLocal() == View.LAYOUT_DIRECTION_LTR;
	setCornerStyles(
	isLtr ? mTopStartCornerStyle : mTopEndCornerStyle,
	isLtr ? mTopEndCornerStyle : mTopStartCornerStyle,
	isLtr ? mBottomEndCornerStyle : mBottomStartCornerStyle,
	isLtr ? mBottomStartCornerStyle : mBottomEndCornerStyle);
	}

	/** Set the corner styles for all four corners */
	private void setCornerStyles(int topLeft, int topRight, int bottomRight, int bottomLeft) {
	boolean changed = mTopLeftCornerStyle != topLeft
	\|\| mTopRightCornerStyle != topRight
	\|\| mBottomRightCornerStyle != bottomRight
	\|\| mBottomLeftCornerStyle != bottomLeft;

	mTopLeftCornerStyle = topLeft;
	mTopRightCornerStyle = topRight;
	mBottomRightCornerStyle = bottomRight;
	mBottomLeftCornerStyle = bottomLeft;

	if (changed) {
	recalculatePath();
	}
	}
	}