v17/leanback/src/android/support/v17/leanback/widget/ShadowOverlayContainer.java - platform/frameworks/support - 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 android.support.v17.leanback.widget;

 import android.content.Context;
 import android.support.annotation.ColorInt;
 import android.support.v17.leanback.R;
 import android.util.AttributeSet;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.graphics.Rect;

 /**
  * Provides an SDK version-independent wrapper to support shadows, color overlays, and rounded
  * corners.
  * <p>
  * {@link #prepareParentForShadow(ViewGroup)} must be called on parent of container
  * before using shadow.  Depending on sdk version, optical bounds might be applied
  * to parent.
  * </p>
  * <p>
  * If shadows can appear outside the bounds of the parent view, setClipChildren(false) must
  * be called on the grandparent view.
  * </p>
  * <p>
  * {@link #initialize(boolean, boolean, boolean)} must be first called on the container.
  * Then call {@link #wrap(View)} to insert the wrapped view into the container.
  * </p>
  * <p>
  * Call {@link #setShadowFocusLevel(float)} to control the strength of the shadow (focused shadows
  * cast stronger shadows).
  * </p>
  * <p>
  * Call {@link #setOverlayColor(int)} to control overlay color.
  * </p>
  */
 public class ShadowOverlayContainer extends ViewGroup {

     /**
      * No shadow.
      */
     public static final int SHADOW_NONE = 1;

     /**
      * Shadows are fixed.
      */
     public static final int SHADOW_STATIC = 2;

     /**
      * Shadows depend on the size, shape, and position of the view.
      */
     public static final int SHADOW_DYNAMIC = 3;

     private boolean mInitialized;
     private View mColorDimOverlay;
     private Object mShadowImpl;
     private View mWrappedView;
     private boolean mRoundedCorners;
     private int mShadowType = SHADOW_NONE;
     private float mUnfocusedZ;
     private float mFocusedZ;
     private static final Rect sTempRect = new Rect();

     public ShadowOverlayContainer(Context context) {
         this(context, null, 0);
     }

     public ShadowOverlayContainer(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }

     public ShadowOverlayContainer(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
         useStaticShadow();
         useDynamicShadow();
     }

     /**
      * Return true if the platform sdk supports shadow.
      */
     public static boolean supportsShadow() {
         return StaticShadowHelper.getInstance().supportsShadow();
     }

     /**
      * Returns true if the platform sdk supports dynamic shadows.
      */
     public static boolean supportsDynamicShadow() {
         return ShadowHelper.getInstance().supportsDynamicShadow();
     }

     /**
      * {@link #prepareParentForShadow(ViewGroup)} must be called on parent of container
      * before using shadow.  Depending on sdk version, optical bounds might be applied
      * to parent.
      */
     public static void prepareParentForShadow(ViewGroup parent) {
         StaticShadowHelper.getInstance().prepareParent(parent);
     }

     /**
      * Sets the shadow type to {@link #SHADOW_DYNAMIC} if supported.
      */
     public void useDynamicShadow() {
         useDynamicShadow(getResources().getDimension(R.dimen.lb_material_shadow_normal_z),
                 getResources().getDimension(R.dimen.lb_material_shadow_focused_z));
     }

     /**
      * Sets the shadow type to {@link #SHADOW_DYNAMIC} if supported and sets the elevation/Z
      * values to the given parameteres.
      */
     public void useDynamicShadow(float unfocusedZ, float focusedZ) {
         if (mInitialized) {
             throw new IllegalStateException("Already initialized");
         }
         if (supportsDynamicShadow()) {
             mShadowType = SHADOW_DYNAMIC;
             mUnfocusedZ = unfocusedZ;
             mFocusedZ = focusedZ;
         }
     }

     /**
      * Sets the shadow type to {@link #SHADOW_STATIC} if supported.
      */
     public void useStaticShadow() {
         if (mInitialized) {
             throw new IllegalStateException("Already initialized");
         }
         if (supportsShadow()) {
             mShadowType = SHADOW_STATIC;
         }
     }

     /**
      * Returns the shadow type, one of {@link #SHADOW_NONE}, {@link #SHADOW_STATIC}, or
      * {@link #SHADOW_DYNAMIC}.
      */
     public int getShadowType() {
         return mShadowType;
     }

     /**
      * Initialize shadows, color overlay.
      * @deprecated use {@link #initialize(boolean, boolean, boolean)} instead.
      */
     @Deprecated
     public void initialize(boolean hasShadow, boolean hasColorDimOverlay) {
         initialize(hasShadow, hasColorDimOverlay, true);
     }

     /**
      * Initialize shadows, color overlay, and rounded corners.  All are optional.
      */
     public void initialize(boolean hasShadow, boolean hasColorDimOverlay, boolean roundedCorners) {
         if (mInitialized) {
             throw new IllegalStateException();
         }
         mInitialized = true;
         if (hasShadow) {
             switch (mShadowType) {
                 case SHADOW_DYNAMIC:
                     mShadowImpl = ShadowHelper.getInstance().addDynamicShadow(
                             this, mUnfocusedZ, mFocusedZ, roundedCorners);
                     break;
                 case SHADOW_STATIC:
                     mShadowImpl = StaticShadowHelper.getInstance().addStaticShadow(
                             this, roundedCorners);
                     break;
             }
         }
         mRoundedCorners = roundedCorners;
         if (hasColorDimOverlay) {
             mColorDimOverlay = LayoutInflater.from(getContext())
                     .inflate(R.layout.lb_card_color_overlay, this, false);
             addView(mColorDimOverlay);
         }
     }

     /**
      * Set shadow focus level (0 to 1). 0 for unfocused, 1f for fully focused.
      */
     public void setShadowFocusLevel(float level) {
         if (mShadowImpl != null) {
             if (level < 0f) {
                 level = 0f;
             } else if (level > 1f) {
                 level = 1f;
             }
             switch (mShadowType) {
                 case SHADOW_DYNAMIC:
                     ShadowHelper.getInstance().setShadowFocusLevel(mShadowImpl, level);
                     break;
                 case SHADOW_STATIC:
                     StaticShadowHelper.getInstance().setShadowFocusLevel(mShadowImpl, level);
                     break;
             }
         }
     }

     /**
      * Set color (with alpha) of the overlay.
      */
     public void setOverlayColor(@ColorInt int overlayColor) {
         if (mColorDimOverlay != null) {
             mColorDimOverlay.setBackgroundColor(overlayColor);
         }
     }

     /**
      * Inserts view into the wrapper.
      */
     public void wrap(View view) {
         if (!mInitialized || mWrappedView != null) {
             throw new IllegalStateException();
         }
         if (mColorDimOverlay != null) {
             addView(view, indexOfChild(mColorDimOverlay));
         } else {
             addView(view);
         }
         mWrappedView = view;
         if (mRoundedCorners) {
             RoundedRectHelper.getInstance().setClipToRoundedOutline(mWrappedView, true);
         }
     }

     /**
      * Returns the wrapper view.
      */
     public View getWrappedView() {
         return mWrappedView;
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         if (mWrappedView == null) {
             throw new IllegalStateException();
         }
         // padding and child margin are not supported.
         // first measure the wrapped view, then measure the shadow view and/or overlay view.
         int childWidthMeasureSpec, childHeightMeasureSpec;
         LayoutParams lp = mWrappedView.getLayoutParams();
         if (lp.width == LayoutParams.MATCH_PARENT) {
             childWidthMeasureSpec = MeasureSpec.makeMeasureSpec
                     (MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.EXACTLY);
         } else {
             childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, lp.width);
         }
         if (lp.height == LayoutParams.MATCH_PARENT) {
             childHeightMeasureSpec = MeasureSpec.makeMeasureSpec
                     (MeasureSpec.getSize(heightMeasureSpec), MeasureSpec.EXACTLY);
         } else {
             childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, lp.height);
         }
         mWrappedView.measure(childWidthMeasureSpec, childHeightMeasureSpec);

         int measuredWidth = mWrappedView.getMeasuredWidth();
         int measuredHeight = mWrappedView.getMeasuredHeight();

         for (int i = 0; i < getChildCount(); i++) {
             View child = getChildAt(i);
             if (child == mWrappedView) {
                 continue;
             }
             lp = child.getLayoutParams();
             if (lp.width == LayoutParams.MATCH_PARENT) {
                 childWidthMeasureSpec = MeasureSpec.makeMeasureSpec
                         (measuredWidth, MeasureSpec.EXACTLY);
             } else {
                 childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, lp.width);
             }

             if (lp.height == LayoutParams.MATCH_PARENT) {
                 childHeightMeasureSpec = MeasureSpec.makeMeasureSpec
                         (measuredHeight, MeasureSpec.EXACTLY);
             } else {
                 childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, lp.height);
             }
             child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
         }
         setMeasuredDimension(measuredWidth, measuredHeight);
     }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         final int count = getChildCount();
         for (int i = 0; i < count; i++) {
             final View child = getChildAt(i);
             if (child.getVisibility() != GONE) {
                 final int width = child.getMeasuredWidth();
                 final int height = child.getMeasuredHeight();
                 child.layout(0, 0, width, height);
             }
         }
         if (mWrappedView != null) {
             sTempRect.left = (int) mWrappedView.getPivotX();
             sTempRect.top = (int) mWrappedView.getPivotY();
             offsetDescendantRectToMyCoords(mWrappedView, sTempRect);
             setPivotX(sTempRect.left);
             setPivotY(sTempRect.top);
         }
     }

 }
	/*
	* 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 android.support.v17.leanback.widget;

	import android.content.Context;
	import android.support.annotation.ColorInt;
	import android.support.v17.leanback.R;
	import android.util.AttributeSet;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.graphics.Rect;

	/**
	* Provides an SDK version-independent wrapper to support shadows, color overlays, and rounded
	* corners.
	* <p>
	* {@link #prepareParentForShadow(ViewGroup)} must be called on parent of container
	* before using shadow. Depending on sdk version, optical bounds might be applied
	* to parent.
	* </p>
	* <p>
	* If shadows can appear outside the bounds of the parent view, setClipChildren(false) must
	* be called on the grandparent view.
	* </p>
	* <p>
	* {@link #initialize(boolean, boolean, boolean)} must be first called on the container.
	* Then call {@link #wrap(View)} to insert the wrapped view into the container.
	* </p>
	* <p>
	* Call {@link #setShadowFocusLevel(float)} to control the strength of the shadow (focused shadows
	* cast stronger shadows).
	* </p>
	* <p>
	* Call {@link #setOverlayColor(int)} to control overlay color.
	* </p>
	*/
	public class ShadowOverlayContainer extends ViewGroup {

	/**
	* No shadow.
	*/
	public static final int SHADOW_NONE = 1;

	/**
	* Shadows are fixed.
	*/
	public static final int SHADOW_STATIC = 2;

	/**
	* Shadows depend on the size, shape, and position of the view.
	*/
	public static final int SHADOW_DYNAMIC = 3;

	private boolean mInitialized;
	private View mColorDimOverlay;
	private Object mShadowImpl;
	private View mWrappedView;
	private boolean mRoundedCorners;
	private int mShadowType = SHADOW_NONE;
	private float mUnfocusedZ;
	private float mFocusedZ;
	private static final Rect sTempRect = new Rect();

	public ShadowOverlayContainer(Context context) {
	this(context, null, 0);
	}

	public ShadowOverlayContainer(Context context, AttributeSet attrs) {
	this(context, attrs, 0);
	}

	public ShadowOverlayContainer(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	useStaticShadow();
	useDynamicShadow();
	}

	/**
	* Return true if the platform sdk supports shadow.
	*/
	public static boolean supportsShadow() {
	return StaticShadowHelper.getInstance().supportsShadow();
	}

	/**
	* Returns true if the platform sdk supports dynamic shadows.
	*/
	public static boolean supportsDynamicShadow() {
	return ShadowHelper.getInstance().supportsDynamicShadow();
	}

	/**
	* {@link #prepareParentForShadow(ViewGroup)} must be called on parent of container
	* before using shadow. Depending on sdk version, optical bounds might be applied
	* to parent.
	*/
	public static void prepareParentForShadow(ViewGroup parent) {
	StaticShadowHelper.getInstance().prepareParent(parent);
	}

	/**
	* Sets the shadow type to {@link #SHADOW_DYNAMIC} if supported.
	*/
	public void useDynamicShadow() {
	useDynamicShadow(getResources().getDimension(R.dimen.lb_material_shadow_normal_z),
	getResources().getDimension(R.dimen.lb_material_shadow_focused_z));
	}

	/**
	* Sets the shadow type to {@link #SHADOW_DYNAMIC} if supported and sets the elevation/Z
	* values to the given parameteres.
	*/
	public void useDynamicShadow(float unfocusedZ, float focusedZ) {
	if (mInitialized) {
	throw new IllegalStateException("Already initialized");
	}
	if (supportsDynamicShadow()) {
	mShadowType = SHADOW_DYNAMIC;
	mUnfocusedZ = unfocusedZ;
	mFocusedZ = focusedZ;
	}
	}

	/**
	* Sets the shadow type to {@link #SHADOW_STATIC} if supported.
	*/
	public void useStaticShadow() {
	if (mInitialized) {
	throw new IllegalStateException("Already initialized");
	}
	if (supportsShadow()) {
	mShadowType = SHADOW_STATIC;
	}
	}

	/**
	* Returns the shadow type, one of {@link #SHADOW_NONE}, {@link #SHADOW_STATIC}, or
	* {@link #SHADOW_DYNAMIC}.
	*/
	public int getShadowType() {
	return mShadowType;
	}

	/**
	* Initialize shadows, color overlay.
	* @deprecated use {@link #initialize(boolean, boolean, boolean)} instead.
	*/
	@Deprecated
	public void initialize(boolean hasShadow, boolean hasColorDimOverlay) {
	initialize(hasShadow, hasColorDimOverlay, true);
	}

	/**
	* Initialize shadows, color overlay, and rounded corners. All are optional.
	*/
	public void initialize(boolean hasShadow, boolean hasColorDimOverlay, boolean roundedCorners) {
	if (mInitialized) {
	throw new IllegalStateException();
	}
	mInitialized = true;
	if (hasShadow) {
	switch (mShadowType) {
	case SHADOW_DYNAMIC:
	mShadowImpl = ShadowHelper.getInstance().addDynamicShadow(
	this, mUnfocusedZ, mFocusedZ, roundedCorners);
	break;
	case SHADOW_STATIC:
	mShadowImpl = StaticShadowHelper.getInstance().addStaticShadow(
	this, roundedCorners);
	break;
	}
	}
	mRoundedCorners = roundedCorners;
	if (hasColorDimOverlay) {
	mColorDimOverlay = LayoutInflater.from(getContext())
	.inflate(R.layout.lb_card_color_overlay, this, false);
	addView(mColorDimOverlay);
	}
	}

	/**
	* Set shadow focus level (0 to 1). 0 for unfocused, 1f for fully focused.
	*/
	public void setShadowFocusLevel(float level) {
	if (mShadowImpl != null) {
	if (level < 0f) {
	level = 0f;
	} else if (level > 1f) {
	level = 1f;
	}
	switch (mShadowType) {
	case SHADOW_DYNAMIC:
	ShadowHelper.getInstance().setShadowFocusLevel(mShadowImpl, level);
	break;
	case SHADOW_STATIC:
	StaticShadowHelper.getInstance().setShadowFocusLevel(mShadowImpl, level);
	break;
	}
	}
	}

	/**
	* Set color (with alpha) of the overlay.
	*/
	public void setOverlayColor(@ColorInt int overlayColor) {
	if (mColorDimOverlay != null) {
	mColorDimOverlay.setBackgroundColor(overlayColor);
	}
	}

	/**
	* Inserts view into the wrapper.
	*/
	public void wrap(View view) {
	if (!mInitialized \|\| mWrappedView != null) {
	throw new IllegalStateException();
	}
	if (mColorDimOverlay != null) {
	addView(view, indexOfChild(mColorDimOverlay));
	} else {
	addView(view);
	}
	mWrappedView = view;
	if (mRoundedCorners) {
	RoundedRectHelper.getInstance().setClipToRoundedOutline(mWrappedView, true);
	}
	}

	/**
	* Returns the wrapper view.
	*/
	public View getWrappedView() {
	return mWrappedView;
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	if (mWrappedView == null) {
	throw new IllegalStateException();
	}
	// padding and child margin are not supported.
	// first measure the wrapped view, then measure the shadow view and/or overlay view.
	int childWidthMeasureSpec, childHeightMeasureSpec;
	LayoutParams lp = mWrappedView.getLayoutParams();
	if (lp.width == LayoutParams.MATCH_PARENT) {
	childWidthMeasureSpec = MeasureSpec.makeMeasureSpec
	(MeasureSpec.getSize(widthMeasureSpec), MeasureSpec.EXACTLY);
	} else {
	childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, lp.width);
	}
	if (lp.height == LayoutParams.MATCH_PARENT) {
	childHeightMeasureSpec = MeasureSpec.makeMeasureSpec
	(MeasureSpec.getSize(heightMeasureSpec), MeasureSpec.EXACTLY);
	} else {
	childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, lp.height);
	}
	mWrappedView.measure(childWidthMeasureSpec, childHeightMeasureSpec);

	int measuredWidth = mWrappedView.getMeasuredWidth();
	int measuredHeight = mWrappedView.getMeasuredHeight();

	for (int i = 0; i < getChildCount(); i++) {
	View child = getChildAt(i);
	if (child == mWrappedView) {
	continue;
	}
	lp = child.getLayoutParams();
	if (lp.width == LayoutParams.MATCH_PARENT) {
	childWidthMeasureSpec = MeasureSpec.makeMeasureSpec
	(measuredWidth, MeasureSpec.EXACTLY);
	} else {
	childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, lp.width);
	}

	if (lp.height == LayoutParams.MATCH_PARENT) {
	childHeightMeasureSpec = MeasureSpec.makeMeasureSpec
	(measuredHeight, MeasureSpec.EXACTLY);
	} else {
	childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, lp.height);
	}
	child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
	}
	setMeasuredDimension(measuredWidth, measuredHeight);
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	final int count = getChildCount();
	for (int i = 0; i < count; i++) {
	final View child = getChildAt(i);
	if (child.getVisibility() != GONE) {
	final int width = child.getMeasuredWidth();
	final int height = child.getMeasuredHeight();
	child.layout(0, 0, width, height);
	}
	}
	if (mWrappedView != null) {
	sTempRect.left = (int) mWrappedView.getPivotX();
	sTempRect.top = (int) mWrappedView.getPivotY();
	offsetDescendantRectToMyCoords(mWrappedView, sTempRect);
	setPivotX(sTempRect.left);
	setPivotY(sTempRect.top);
	}
	}

	}