src/com/android/contacts/widget/InterpolatingLayout.java - LeafOS-Project/android_packages_apps_Contacts - Gitiles

 /*
  * Copyright (C) 2010 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.contacts.widget;

 import android.content.Context;
 import android.content.res.TypedArray;
 import android.graphics.Rect;
 import android.util.AttributeSet;
 import android.view.Gravity;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.LinearLayout;

 import com.android.contacts.R;

 /**
  * Layout similar to LinearLayout that allows a child to specify examples of
  * desired size depending on the parent size. For example if the widget wants to
  * be 100dip when parent is 200dip and 110dip when parent is 400dip, the layout
  * will ensure these requirements and interpolate for other parent sizes.
  * You can also specify minWidth for each child.  You can have at most one
  * child with layout_width="match_parent" - it will take the entire remaining
  * space.
  */
 public class InterpolatingLayout extends ViewGroup {

     private Rect mInRect = new Rect();
     private Rect mOutRect = new Rect();

     public InterpolatingLayout(Context context) {
         super(context);
     }

     public InterpolatingLayout(Context context, AttributeSet attrs) {
         super(context, attrs);
     }

     public InterpolatingLayout(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
     }

     public final static class LayoutParams extends LinearLayout.LayoutParams {

         public int narrowParentWidth;
         public int narrowWidth;
         public int narrowMarginLeft;
         public int narrowPaddingLeft;
         public int narrowMarginRight;
         public int narrowPaddingRight;
         public int wideParentWidth;
         public int wideWidth;
         public int wideMarginLeft;
         public int widePaddingLeft;
         public int wideMarginRight;
         public int widePaddingRight;
         private float widthMultiplier;
         private int widthConstant;
         private float leftMarginMultiplier;
         private int leftMarginConstant;
         private float leftPaddingMultiplier;
         private int leftPaddingConstant;
         private float rightMarginMultiplier;
         private int rightMarginConstant;
         private float rightPaddingMultiplier;
         private int rightPaddingConstant;

         public LayoutParams(Context c, AttributeSet attrs) {
             super(c, attrs);
             TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.InterpolatingLayout_Layout);

             narrowParentWidth = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowParentWidth, -1);
             narrowWidth = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowWidth, -1);
             narrowMarginLeft = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowMarginLeft, -1);
             narrowPaddingLeft = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowPaddingLeft, -1);
             narrowMarginRight = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowMarginRight, -1);
             narrowPaddingRight = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_narrowPaddingRight, -1);
             wideParentWidth = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_wideParentWidth, -1);
             wideWidth = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_wideWidth, -1);
             wideMarginLeft = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_wideMarginLeft, -1);
             widePaddingLeft = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_widePaddingLeft, -1);
             wideMarginRight = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_wideMarginRight, -1);
             widePaddingRight = a.getDimensionPixelSize(
                     R.styleable.InterpolatingLayout_Layout_layout_widePaddingRight, -1);

             a.recycle();

             if (narrowWidth != -1) {
                 widthMultiplier = (float) (wideWidth - narrowWidth)
                         / (wideParentWidth - narrowParentWidth);
                 widthConstant = (int) (narrowWidth - narrowParentWidth * widthMultiplier);
             }

             if (narrowMarginLeft != -1) {
                 leftMarginMultiplier = (float) (wideMarginLeft - narrowMarginLeft)
                         / (wideParentWidth - narrowParentWidth);
                 leftMarginConstant = (int) (narrowMarginLeft - narrowParentWidth
                         * leftMarginMultiplier);
             }

             if (narrowPaddingLeft != -1) {
                 leftPaddingMultiplier = (float) (widePaddingLeft - narrowPaddingLeft)
                         / (wideParentWidth - narrowParentWidth);
                 leftPaddingConstant = (int) (narrowPaddingLeft - narrowParentWidth
                         * leftPaddingMultiplier);
             }

             if (narrowMarginRight != -1) {
                 rightMarginMultiplier = (float) (wideMarginRight - narrowMarginRight)
                         / (wideParentWidth - narrowParentWidth);
                 rightMarginConstant = (int) (narrowMarginRight - narrowParentWidth
                         * rightMarginMultiplier);
             }

             if (narrowPaddingRight != -1) {
                 rightPaddingMultiplier = (float) (widePaddingRight - narrowPaddingRight)
                         / (wideParentWidth - narrowParentWidth);
                 rightPaddingConstant = (int) (narrowPaddingRight - narrowParentWidth
                         * rightPaddingMultiplier);
             }
         }

         public LayoutParams(int width, int height) {
             super(width, height);
         }

         public LayoutParams(MarginLayoutParams source) {
             super(source);
         }

         public int resolveWidth(int parentSize) {
             if (narrowWidth == -1) {
                 return width;
             } else {
                 int w = (int) (parentSize * widthMultiplier) + widthConstant;
                 return w <= 0 ? WRAP_CONTENT : w;
             }
         }

         public int resolveLeftMargin(int parentSize) {
             if (narrowMarginLeft == -1) {
                 return leftMargin;
             } else {
                 int w = (int) (parentSize * leftMarginMultiplier) + leftMarginConstant;
                 return w < 0 ? 0 : w;
             }
         }

         public int resolveLeftPadding(int parentSize) {
             int w = (int) (parentSize * leftPaddingMultiplier) + leftPaddingConstant;
             return w < 0 ? 0 : w;
         }

         public int resolveRightMargin(int parentSize) {
             if (narrowMarginRight == -1) {
                 return rightMargin;
             } else {
                 int w = (int) (parentSize * rightMarginMultiplier) + rightMarginConstant;
                 return w < 0 ? 0 : w;
             }
         }

         public int resolveRightPadding(int parentSize) {
             int w = (int) (parentSize * rightPaddingMultiplier) + rightPaddingConstant;
             return w < 0 ? 0 : w;
         }
     }

     @Override
     public LayoutParams generateLayoutParams(AttributeSet attrs) {
         return new LayoutParams(getContext(), attrs);
     }

     @Override
     protected LayoutParams generateDefaultLayoutParams() {
         return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
     }

     @Override
     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
         int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
         int parentHeight = MeasureSpec.getSize(heightMeasureSpec);

         int width = 0;
         int height = 0;

         View fillChild = null;
         int count = getChildCount();
         for (int i = 0; i < count; i++) {
             View child = getChildAt(i);
             if (child.getVisibility() == View.GONE) {
                 continue;
             }

             LayoutParams params = (LayoutParams) child.getLayoutParams();
             if (params.width == LayoutParams.MATCH_PARENT) {
                 if (fillChild != null) {
                     throw new RuntimeException(
                             "Interpolating layout allows at most one child"
                             + " with layout_width='match_parent'");
                 }
                 fillChild = child;
             } else {
                 int childWidth = params.resolveWidth(parentWidth);
                 int childWidthMeasureSpec;
                 switch (childWidth) {
                     case LayoutParams.WRAP_CONTENT:
                         childWidthMeasureSpec = MeasureSpec.UNSPECIFIED;
                         break;
                     default:
                         childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
                                 childWidth, MeasureSpec.EXACTLY);
                         break;
                 }

                 int childHeightMeasureSpec;
                 switch (params.height) {
                     case LayoutParams.WRAP_CONTENT:
                         childHeightMeasureSpec = MeasureSpec.UNSPECIFIED;
                         break;
                     case LayoutParams.MATCH_PARENT:
                         childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                                 parentHeight - params.topMargin - params.bottomMargin,
                                 MeasureSpec.EXACTLY);
                         break;
                     default:
                         childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
                                 params.height, MeasureSpec.EXACTLY);
                         break;
                 }

                 child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
                 width += child.getMeasuredWidth();
                 height = Math.max(child.getMeasuredHeight(), height);
             }

             width += params.resolveLeftMargin(parentWidth) + params.resolveRightMargin(parentWidth);
         }

         if (fillChild != null) {
             int remainder = parentWidth - width;
             int childMeasureSpec = remainder > 0
                     ? MeasureSpec.makeMeasureSpec(remainder, MeasureSpec.EXACTLY)
                     : MeasureSpec.UNSPECIFIED;
             fillChild.measure(childMeasureSpec, heightMeasureSpec);
             width += fillChild.getMeasuredWidth();
             height = Math.max(fillChild.getMeasuredHeight(), height);
         }

         setMeasuredDimension(
                 resolveSize(width, widthMeasureSpec), resolveSize(height, heightMeasureSpec));
     }

     @Override
     protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
         int offset = 0;
         int width = right - left;
         int count = getChildCount();
         for (int i = 0; i < count; i++) {
             View child = getChildAt(i);

             if (child.getVisibility() == View.GONE) {
                 continue;
             }

             LayoutParams params = (LayoutParams) child.getLayoutParams();
             int gravity = params.gravity;
             if (gravity == -1) {
                 gravity = Gravity.START | Gravity.TOP;
             }

             if (params.narrowPaddingLeft != -1 || params.narrowPaddingRight != -1) {
                 int leftPadding = params.narrowPaddingLeft == -1 ? child.getPaddingLeft()
                         : params.resolveLeftPadding(width);
                 int rightPadding = params.narrowPaddingRight == -1 ? child.getPaddingRight()
                         : params.resolveRightPadding(width);
                 child.setPadding(
                         leftPadding, child.getPaddingTop(), rightPadding, child.getPaddingBottom());
             }

             int leftMargin = params.resolveLeftMargin(width);
             int rightMargin = params.resolveRightMargin(width);

             mInRect.set(offset + leftMargin, params.topMargin,
                     right - rightMargin, bottom - params.bottomMargin);

             Gravity.apply(gravity, child.getMeasuredWidth(), child.getMeasuredHeight(),
                     mInRect, mOutRect);
             child.layout(mOutRect.left, mOutRect.top, mOutRect.right, mOutRect.bottom);

             offset = mOutRect.right + rightMargin;
         }
     }
 }
	/*
	* Copyright (C) 2010 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.contacts.widget;

	import android.content.Context;
	import android.content.res.TypedArray;
	import android.graphics.Rect;
	import android.util.AttributeSet;
	import android.view.Gravity;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.LinearLayout;

	import com.android.contacts.R;

	/**
	* Layout similar to LinearLayout that allows a child to specify examples of
	* desired size depending on the parent size. For example if the widget wants to
	* be 100dip when parent is 200dip and 110dip when parent is 400dip, the layout
	* will ensure these requirements and interpolate for other parent sizes.
	* You can also specify minWidth for each child. You can have at most one
	* child with layout_width="match_parent" - it will take the entire remaining
	* space.
	*/
	public class InterpolatingLayout extends ViewGroup {

	private Rect mInRect = new Rect();
	private Rect mOutRect = new Rect();

	public InterpolatingLayout(Context context) {
	super(context);
	}

	public InterpolatingLayout(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

	public InterpolatingLayout(Context context, AttributeSet attrs, int defStyle) {
	super(context, attrs, defStyle);
	}

	public final static class LayoutParams extends LinearLayout.LayoutParams {

	public int narrowParentWidth;
	public int narrowWidth;
	public int narrowMarginLeft;
	public int narrowPaddingLeft;
	public int narrowMarginRight;
	public int narrowPaddingRight;
	public int wideParentWidth;
	public int wideWidth;
	public int wideMarginLeft;
	public int widePaddingLeft;
	public int wideMarginRight;
	public int widePaddingRight;
	private float widthMultiplier;
	private int widthConstant;
	private float leftMarginMultiplier;
	private int leftMarginConstant;
	private float leftPaddingMultiplier;
	private int leftPaddingConstant;
	private float rightMarginMultiplier;
	private int rightMarginConstant;
	private float rightPaddingMultiplier;
	private int rightPaddingConstant;

	public LayoutParams(Context c, AttributeSet attrs) {
	super(c, attrs);
	TypedArray a = c.obtainStyledAttributes(attrs, R.styleable.InterpolatingLayout_Layout);

	narrowParentWidth = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowParentWidth, -1);
	narrowWidth = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowWidth, -1);
	narrowMarginLeft = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowMarginLeft, -1);
	narrowPaddingLeft = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowPaddingLeft, -1);
	narrowMarginRight = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowMarginRight, -1);
	narrowPaddingRight = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_narrowPaddingRight, -1);
	wideParentWidth = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_wideParentWidth, -1);
	wideWidth = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_wideWidth, -1);
	wideMarginLeft = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_wideMarginLeft, -1);
	widePaddingLeft = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_widePaddingLeft, -1);
	wideMarginRight = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_wideMarginRight, -1);
	widePaddingRight = a.getDimensionPixelSize(
	R.styleable.InterpolatingLayout_Layout_layout_widePaddingRight, -1);

	a.recycle();

	if (narrowWidth != -1) {
	widthMultiplier = (float) (wideWidth - narrowWidth)
	/ (wideParentWidth - narrowParentWidth);
	widthConstant = (int) (narrowWidth - narrowParentWidth * widthMultiplier);
	}

	if (narrowMarginLeft != -1) {
	leftMarginMultiplier = (float) (wideMarginLeft - narrowMarginLeft)
	/ (wideParentWidth - narrowParentWidth);
	leftMarginConstant = (int) (narrowMarginLeft - narrowParentWidth
	* leftMarginMultiplier);
	}

	if (narrowPaddingLeft != -1) {
	leftPaddingMultiplier = (float) (widePaddingLeft - narrowPaddingLeft)
	/ (wideParentWidth - narrowParentWidth);
	leftPaddingConstant = (int) (narrowPaddingLeft - narrowParentWidth
	* leftPaddingMultiplier);
	}

	if (narrowMarginRight != -1) {
	rightMarginMultiplier = (float) (wideMarginRight - narrowMarginRight)
	/ (wideParentWidth - narrowParentWidth);
	rightMarginConstant = (int) (narrowMarginRight - narrowParentWidth
	* rightMarginMultiplier);
	}

	if (narrowPaddingRight != -1) {
	rightPaddingMultiplier = (float) (widePaddingRight - narrowPaddingRight)
	/ (wideParentWidth - narrowParentWidth);
	rightPaddingConstant = (int) (narrowPaddingRight - narrowParentWidth
	* rightPaddingMultiplier);
	}
	}

	public LayoutParams(int width, int height) {
	super(width, height);
	}

	public LayoutParams(MarginLayoutParams source) {
	super(source);
	}

	public int resolveWidth(int parentSize) {
	if (narrowWidth == -1) {
	return width;
	} else {
	int w = (int) (parentSize * widthMultiplier) + widthConstant;
	return w <= 0 ? WRAP_CONTENT : w;
	}
	}

	public int resolveLeftMargin(int parentSize) {
	if (narrowMarginLeft == -1) {
	return leftMargin;
	} else {
	int w = (int) (parentSize * leftMarginMultiplier) + leftMarginConstant;
	return w < 0 ? 0 : w;
	}
	}

	public int resolveLeftPadding(int parentSize) {
	int w = (int) (parentSize * leftPaddingMultiplier) + leftPaddingConstant;
	return w < 0 ? 0 : w;
	}

	public int resolveRightMargin(int parentSize) {
	if (narrowMarginRight == -1) {
	return rightMargin;
	} else {
	int w = (int) (parentSize * rightMarginMultiplier) + rightMarginConstant;
	return w < 0 ? 0 : w;
	}
	}

	public int resolveRightPadding(int parentSize) {
	int w = (int) (parentSize * rightPaddingMultiplier) + rightPaddingConstant;
	return w < 0 ? 0 : w;
	}
	}

	@Override
	public LayoutParams generateLayoutParams(AttributeSet attrs) {
	return new LayoutParams(getContext(), attrs);
	}

	@Override
	protected LayoutParams generateDefaultLayoutParams() {
	return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	int parentWidth = MeasureSpec.getSize(widthMeasureSpec);
	int parentHeight = MeasureSpec.getSize(heightMeasureSpec);

	int width = 0;
	int height = 0;

	View fillChild = null;
	int count = getChildCount();
	for (int i = 0; i < count; i++) {
	View child = getChildAt(i);
	if (child.getVisibility() == View.GONE) {
	continue;
	}

	LayoutParams params = (LayoutParams) child.getLayoutParams();
	if (params.width == LayoutParams.MATCH_PARENT) {
	if (fillChild != null) {
	throw new RuntimeException(
	"Interpolating layout allows at most one child"
	+ " with layout_width='match_parent'");
	}
	fillChild = child;
	} else {
	int childWidth = params.resolveWidth(parentWidth);
	int childWidthMeasureSpec;
	switch (childWidth) {
	case LayoutParams.WRAP_CONTENT:
	childWidthMeasureSpec = MeasureSpec.UNSPECIFIED;
	break;
	default:
	childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(
	childWidth, MeasureSpec.EXACTLY);
	break;
	}

	int childHeightMeasureSpec;
	switch (params.height) {
	case LayoutParams.WRAP_CONTENT:
	childHeightMeasureSpec = MeasureSpec.UNSPECIFIED;
	break;
	case LayoutParams.MATCH_PARENT:
	childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
	parentHeight - params.topMargin - params.bottomMargin,
	MeasureSpec.EXACTLY);
	break;
	default:
	childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(
	params.height, MeasureSpec.EXACTLY);
	break;
	}

	child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
	width += child.getMeasuredWidth();
	height = Math.max(child.getMeasuredHeight(), height);
	}

	width += params.resolveLeftMargin(parentWidth) + params.resolveRightMargin(parentWidth);
	}

	if (fillChild != null) {
	int remainder = parentWidth - width;
	int childMeasureSpec = remainder > 0
	? MeasureSpec.makeMeasureSpec(remainder, MeasureSpec.EXACTLY)
	: MeasureSpec.UNSPECIFIED;
	fillChild.measure(childMeasureSpec, heightMeasureSpec);
	width += fillChild.getMeasuredWidth();
	height = Math.max(fillChild.getMeasuredHeight(), height);
	}

	setMeasuredDimension(
	resolveSize(width, widthMeasureSpec), resolveSize(height, heightMeasureSpec));
	}

	@Override
	protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
	int offset = 0;
	int width = right - left;
	int count = getChildCount();
	for (int i = 0; i < count; i++) {
	View child = getChildAt(i);

	if (child.getVisibility() == View.GONE) {
	continue;
	}

	LayoutParams params = (LayoutParams) child.getLayoutParams();
	int gravity = params.gravity;
	if (gravity == -1) {
	gravity = Gravity.START \| Gravity.TOP;
	}

	if (params.narrowPaddingLeft != -1 \|\| params.narrowPaddingRight != -1) {
	int leftPadding = params.narrowPaddingLeft == -1 ? child.getPaddingLeft()
	: params.resolveLeftPadding(width);
	int rightPadding = params.narrowPaddingRight == -1 ? child.getPaddingRight()
	: params.resolveRightPadding(width);
	child.setPadding(
	leftPadding, child.getPaddingTop(), rightPadding, child.getPaddingBottom());
	}

	int leftMargin = params.resolveLeftMargin(width);
	int rightMargin = params.resolveRightMargin(width);

	mInRect.set(offset + leftMargin, params.topMargin,
	right - rightMargin, bottom - params.bottomMargin);

	Gravity.apply(gravity, child.getMeasuredWidth(), child.getMeasuredHeight(),
	mInRect, mOutRect);
	child.layout(mOutRect.left, mOutRect.top, mOutRect.right, mOutRect.bottom);

	offset = mOutRect.right + rightMargin;
	}
	}
	}