percent/src/android/support/percent/PercentLayoutHelper.java - platform/frameworks/support - Git at Google

 /*
  * Copyright (C) 2015 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.percent;

 import android.content.Context;
 import android.content.res.TypedArray;
 import android.support.v4.view.MarginLayoutParamsCompat;
 import android.support.v4.view.ViewCompat;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;

 import android.support.percent.R;

 /**
  * Helper for layouts that want to support percentage based dimensions.
  *
  * <p>This class collects utility methods that are involved in extracting percentage based dimension
  * attributes and applying them to ViewGroup's children. If you would like to implement a layout
  * that supports percentage based dimensions, you need to take several steps:
  *
  * <ol>
  * <li> You need a {@link ViewGroup.LayoutParams} subclass in your ViewGroup that implements
  * {@link android.support.percent.PercentLayoutHelper.PercentLayoutParams}.
  * <li> In your {@code LayoutParams(Context c, AttributeSet attrs)} constructor create an instance
  * of {@link PercentLayoutHelper.PercentLayoutInfo} by calling
  * {@link PercentLayoutHelper#getPercentLayoutInfo(Context, AttributeSet)}. Return this
  * object from {@code public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo()}
  * method that you implemented for {@link android.support.percent.PercentLayoutHelper.PercentLayoutParams} interface.
  * <li> Override
  * {@link ViewGroup.LayoutParams#setBaseAttributes(TypedArray, int, int)}
  * with a single line implementation {@code PercentLayoutHelper.fetchWidthAndHeight(this, a,
  * widthAttr, heightAttr);}
  * <li> In your ViewGroup override {@link ViewGroup#generateLayoutParams(AttributeSet)} to return
  * your LayoutParams.
  * <li> In your {@link ViewGroup#onMeasure(int, int)} override, you need to implement following
  * pattern:
  * <pre class="prettyprint">
  * protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  *     mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
  *     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  *     if (mHelper.handleMeasuredStateTooSmall()) {
  *         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
  *     }
  * }
  * </pre>
  * <li>In your {@link ViewGroup#onLayout(boolean, int, int, int, int)} override, you need to
  * implement following pattern:
  * <pre class="prettyprint">
  * protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
  *     super.onLayout(changed, left, top, right, bottom);
  *     mHelper.restoreOriginalParams();
  * }
  * </pre>
  * </ol>
  */
 public class PercentLayoutHelper {
     private static final String TAG = "PercentLayout";

     private static final int SNAP_TO_NONE = 0;
     private static final int SNAP_TO_WIDTH = 1;
     private static final int SNAP_TO_HEIGHT = 2;

     private final ViewGroup mHost;

     public PercentLayoutHelper(ViewGroup host) {
         mHost = host;
     }

     /**
      * Helper method to be called from {@link ViewGroup.LayoutParams#setBaseAttributes} override
      * that reads layout_width and layout_height attribute values without throwing an exception if
      * they aren't present.
      */
     public static void fetchWidthAndHeight(ViewGroup.LayoutParams params, TypedArray array,
             int widthAttr, int heightAttr) {
         params.width = array.getLayoutDimension(widthAttr, 0);
         params.height = array.getLayoutDimension(heightAttr, 0);
     }

     /**
      * Iterates over children and changes their width and height to one calculated from percentage
      * values.
      * @param widthMeasureSpec Width MeasureSpec of the parent ViewGroup.
      * @param heightMeasureSpec Height MeasureSpec of the parent ViewGroup.
      */
     public void adjustChildren(int widthMeasureSpec, int heightMeasureSpec) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "adjustChildren: " + mHost + " widthMeasureSpec: "
                     + View.MeasureSpec.toString(widthMeasureSpec) + " heightMeasureSpec: "
                     + View.MeasureSpec.toString(heightMeasureSpec));
         }

         int widthHint = View.MeasureSpec.getSize(widthMeasureSpec);
         int heightHint = View.MeasureSpec.getSize(heightMeasureSpec);
         for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
             View view = mHost.getChildAt(i);
             ViewGroup.LayoutParams params = view.getLayoutParams();
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "should adjust " + view + " " + params);
             }
             if (params instanceof PercentLayoutParams) {
                 PercentLayoutInfo info =
                         ((PercentLayoutParams) params).getPercentLayoutInfo();
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "using " + info);
                 }
                 if (info != null) {
                     if (params instanceof ViewGroup.MarginLayoutParams) {
                         info.fillMarginLayoutParams((ViewGroup.MarginLayoutParams) params,
                                 widthHint, heightHint, info.snapToDimen);
                     } else {
                         info.fillLayoutParams(params, widthHint, heightHint, info.snapToDimen);
                     }
                 }
             }
         }
     }

     /**
      * Constructs a PercentLayoutInfo from attributes associated with a View. Call this method from
      * {@code LayoutParams(Context c, AttributeSet attrs)} constructor.
      */
     public static PercentLayoutInfo getPercentLayoutInfo(Context context,
             AttributeSet attrs) {
         PercentLayoutInfo info = null;
         TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.PercentLayout_Layout);
         float value = array.getFraction(R.styleable.PercentLayout_Layout_layout_widthPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent width: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.widthPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_heightPercent, 1, 1, -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent height: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.heightPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginPercent, 1, 1, -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.leftMarginPercent = value;
             info.topMarginPercent = value;
             info.rightMarginPercent = value;
             info.bottomMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginLeftPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent left margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.leftMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginTopPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent top margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.topMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginRightPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent right margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.rightMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginBottomPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent bottom margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.bottomMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginStartPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent start margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.startMarginPercent = value;
         }
         value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginEndPercent, 1, 1,
                 -1f);
         if (value != -1f) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 Log.v(TAG, "percent end margin: " + value);
             }
             info = info != null ? info : new PercentLayoutInfo();
             info.endMarginPercent = value;
         }

         int snapToDimen = array.getInt(R.styleable.PercentLayout_Layout_layout_snapToDimen,
                 SNAP_TO_NONE);

         if (snapToDimen != SNAP_TO_NONE) {
             info = info != null ? info : new PercentLayoutInfo();
             info.snapToDimen = snapToDimen;
         }

         array.recycle();
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "constructed: " + info);
         }
         return info;
     }

     /**
      * Iterates over children and restores their original dimensions that were changed for
      * percentage values. Calling this method only makes sense if you previously called
      * {@link PercentLayoutHelper#adjustChildren(int, int)}.
      */
     public void restoreOriginalParams() {
         for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
             View view = mHost.getChildAt(i);
             ViewGroup.LayoutParams params = view.getLayoutParams();
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "should restore " + view + " " + params);
             }
             if (params instanceof PercentLayoutParams) {
                 PercentLayoutInfo info =
                         ((PercentLayoutParams) params).getPercentLayoutInfo();
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "using " + info);
                 }
                 if (info != null) {
                     if (params instanceof ViewGroup.MarginLayoutParams) {
                         info.restoreMarginLayoutParams((ViewGroup.MarginLayoutParams) params);
                     } else {
                         info.restoreLayoutParams(params);
                     }
                 }
             }
         }
     }

     /**
      * Iterates over children and checks if any of them would like to get more space than it
      * received through the percentage dimension.
      *
      * If you are building a layout that supports percentage dimensions you are encouraged to take
      * advantage of this method. The developer should be able to specify that a child should be
      * remeasured by adding normal dimension attribute with {@code wrap_content} value. For example
      * he might specify child's attributes as {@code app:layout_widthPercent="60%p"} and
      * {@code android:layout_width="wrap_content"}. In this case if the child receives too little
      * space, it will be remeasured with width set to {@code WRAP_CONTENT}.
      *
      * @return True if the measure phase needs to be rerun because one of the children would like
      * to receive more space.
      */
     public boolean handleMeasuredStateTooSmall() {
         boolean needsSecondMeasure = false;
         for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
             View view = mHost.getChildAt(i);
             ViewGroup.LayoutParams params = view.getLayoutParams();
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "should handle measured state too small " + view + " " + params);
             }
             if (params instanceof PercentLayoutParams) {
                 PercentLayoutInfo info =
                         ((PercentLayoutParams) params).getPercentLayoutInfo();
                 if (info != null) {
                     if (shouldHandleMeasuredWidthTooSmall(view, info)) {
                         needsSecondMeasure = true;
                         params.width = ViewGroup.LayoutParams.WRAP_CONTENT;
                     }
                     if (shouldHandleMeasuredHeightTooSmall(view, info)) {
                         needsSecondMeasure = true;
                         params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
                     }
                 }
             }
         }
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "should trigger second measure pass: " + needsSecondMeasure);
         }
         return needsSecondMeasure;
     }

     private static boolean shouldHandleMeasuredWidthTooSmall(View view, PercentLayoutInfo info) {
         int state = ViewCompat.getMeasuredWidthAndState(view) & ViewCompat.MEASURED_STATE_MASK;
         return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.widthPercent >= 0 &&
                 info.mPreservedParams.width == ViewGroup.LayoutParams.WRAP_CONTENT;
     }

     private static boolean shouldHandleMeasuredHeightTooSmall(View view, PercentLayoutInfo info) {
         int state = ViewCompat.getMeasuredHeightAndState(view) & ViewCompat.MEASURED_STATE_MASK;
         return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.heightPercent >= 0 &&
                 info.mPreservedParams.height == ViewGroup.LayoutParams.WRAP_CONTENT;
     }

     /**
      * Container for information about percentage dimensions and margins. It acts as an extension
      * for {@code LayoutParams}.
      */
     public static class PercentLayoutInfo {
         public float widthPercent;

         public float heightPercent;

         public float leftMarginPercent;

         public float topMarginPercent;

         public float rightMarginPercent;

         public float bottomMarginPercent;

         public float startMarginPercent;

         public float endMarginPercent;

         public int snapToDimen;

         /* package */ final ViewGroup.MarginLayoutParams mPreservedParams;

         public PercentLayoutInfo() {
             widthPercent = -1f;
             heightPercent = -1f;
             leftMarginPercent = -1f;
             topMarginPercent = -1f;
             rightMarginPercent = -1f;
             bottomMarginPercent = -1f;
             startMarginPercent = -1f;
             endMarginPercent = -1f;
             mPreservedParams = new ViewGroup.MarginLayoutParams(0, 0);
         }

         /**
          * Fills {@code ViewGroup.LayoutParams} dimensions based on percentage values.
          */
         public void fillLayoutParams(ViewGroup.LayoutParams params, int widthHint,
                 int heightHint, int snapToDimen) {
             // Preserve the original layout params, so we can restore them after the measure step.
             mPreservedParams.width = params.width;
             mPreservedParams.height = params.height;

             if (widthPercent >= 0) {
                 params.width = (int) (widthHint * widthPercent);
             }

             if (heightPercent >= 0) {
                 params.height = (int) (heightHint * heightPercent);
             }

             switch (snapToDimen) {
                 case SNAP_TO_HEIGHT:
                     params.width = params.height;
                     break;
                 case SNAP_TO_WIDTH:
                     params.height = params.width;
                     break;
             }

             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "after fillLayoutParams: (" + params.width + ", " + params.height + ")");
             }
         }

         /**
          * Fills {@code ViewGroup.MarginLayoutParams} dimensions and margins based on percentage
          * values.
          */
         public void fillMarginLayoutParams(ViewGroup.MarginLayoutParams params, int widthHint,
                 int heightHint, int snapToDimen) {
             fillLayoutParams(params, widthHint, heightHint, snapToDimen);

             // Preserver the original margins, so we can restore them after the measure step.
             mPreservedParams.leftMargin = params.leftMargin;
             mPreservedParams.topMargin = params.topMargin;
             mPreservedParams.rightMargin = params.rightMargin;
             mPreservedParams.bottomMargin = params.bottomMargin;
             MarginLayoutParamsCompat.setMarginStart(mPreservedParams,
                     MarginLayoutParamsCompat.getMarginStart(params));
             MarginLayoutParamsCompat.setMarginEnd(mPreservedParams,
                     MarginLayoutParamsCompat.getMarginEnd(params));

             if (leftMarginPercent >= 0) {
                 params.leftMargin = (int) (widthHint * leftMarginPercent);
             }
             if (topMarginPercent >= 0) {
                 params.topMargin = (int) (heightHint * topMarginPercent);
             }
             if (rightMarginPercent >= 0) {
                 params.rightMargin = (int) (widthHint * rightMarginPercent);
             }
             if (bottomMarginPercent >= 0) {
                 params.bottomMargin = (int) (heightHint * bottomMarginPercent);
             }
             if (startMarginPercent >= 0) {
                 MarginLayoutParamsCompat.setMarginStart(params,
                         (int) (widthHint * startMarginPercent));
             }
             if (endMarginPercent >= 0) {
                 MarginLayoutParamsCompat.setMarginEnd(params,
                         (int) (widthHint * endMarginPercent));
             }
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "after fillMarginLayoutParams: (" + params.width + ", " + params.height
                         + ")");
             }
         }

         @Override
         public String toString() {
             return String.format("PercentLayoutInformation width: %f height %f, margins (%f, %f, "
                             + " %f, %f, %f, %f)", widthPercent, heightPercent, leftMarginPercent,
                     topMarginPercent, rightMarginPercent, bottomMarginPercent, startMarginPercent,
                     endMarginPercent);

         }

         /**
          * Restores original dimensions and margins after they were changed for percentage based
          * values. Calling this method only makes sense if you previously called
          * {@link PercentLayoutHelper.PercentLayoutInfo#fillMarginLayoutParams}.
          */
         public void restoreMarginLayoutParams(ViewGroup.MarginLayoutParams params) {
             restoreLayoutParams(params);
             params.leftMargin = mPreservedParams.leftMargin;
             params.topMargin = mPreservedParams.topMargin;
             params.rightMargin = mPreservedParams.rightMargin;
             params.bottomMargin = mPreservedParams.bottomMargin;
             MarginLayoutParamsCompat.setMarginStart(params,
                     MarginLayoutParamsCompat.getMarginStart(mPreservedParams));
             MarginLayoutParamsCompat.setMarginEnd(params,
                     MarginLayoutParamsCompat.getMarginEnd(mPreservedParams));
         }

         /**
          * Restores original dimensions after they were changed for percentage based values. Calling
          * this method only makes sense if you previously called
          * {@link PercentLayoutHelper.PercentLayoutInfo#fillLayoutParams}.
          */
         public void restoreLayoutParams(ViewGroup.LayoutParams params) {
             params.width = mPreservedParams.width;
             params.height = mPreservedParams.height;
         }
     }

     /**
      * If a layout wants to support percentage based dimensions and use this helper class, its
      * {@code LayoutParams} subclass must implement this interface.
      *
      * Your {@code LayoutParams} subclass should contain an instance of {@code PercentLayoutInfo}
      * and the implementation of this interface should be a simple accessor.
      */
     public interface PercentLayoutParams {
         PercentLayoutInfo getPercentLayoutInfo();
     }
 }
	/*
	* Copyright (C) 2015 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.percent;

	import android.content.Context;
	import android.content.res.TypedArray;
	import android.support.v4.view.MarginLayoutParamsCompat;
	import android.support.v4.view.ViewCompat;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;

	import android.support.percent.R;

	/**
	* Helper for layouts that want to support percentage based dimensions.
	*
	* <p>This class collects utility methods that are involved in extracting percentage based dimension
	* attributes and applying them to ViewGroup's children. If you would like to implement a layout
	* that supports percentage based dimensions, you need to take several steps:
	*
	* <ol>
	* <li> You need a {@link ViewGroup.LayoutParams} subclass in your ViewGroup that implements
	* {@link android.support.percent.PercentLayoutHelper.PercentLayoutParams}.
	* <li> In your {@code LayoutParams(Context c, AttributeSet attrs)} constructor create an instance
	* of {@link PercentLayoutHelper.PercentLayoutInfo} by calling
	* {@link PercentLayoutHelper#getPercentLayoutInfo(Context, AttributeSet)}. Return this
	* object from {@code public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo()}
	* method that you implemented for {@link android.support.percent.PercentLayoutHelper.PercentLayoutParams} interface.
	* <li> Override
	* {@link ViewGroup.LayoutParams#setBaseAttributes(TypedArray, int, int)}
	* with a single line implementation {@code PercentLayoutHelper.fetchWidthAndHeight(this, a,
	* widthAttr, heightAttr);}
	* <li> In your ViewGroup override {@link ViewGroup#generateLayoutParams(AttributeSet)} to return
	* your LayoutParams.
	* <li> In your {@link ViewGroup#onMeasure(int, int)} override, you need to implement following
	* pattern:
	* <pre class="prettyprint">
	* protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
	* mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
	* super.onMeasure(widthMeasureSpec, heightMeasureSpec);
	* if (mHelper.handleMeasuredStateTooSmall()) {
	* super.onMeasure(widthMeasureSpec, heightMeasureSpec);
	* }
	* }
	* </pre>
	* <li>In your {@link ViewGroup#onLayout(boolean, int, int, int, int)} override, you need to
	* implement following pattern:
	* <pre class="prettyprint">
	* protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
	* super.onLayout(changed, left, top, right, bottom);
	* mHelper.restoreOriginalParams();
	* }
	* </pre>
	* </ol>
	*/
	public class PercentLayoutHelper {
	private static final String TAG = "PercentLayout";

	private static final int SNAP_TO_NONE = 0;
	private static final int SNAP_TO_WIDTH = 1;
	private static final int SNAP_TO_HEIGHT = 2;

	private final ViewGroup mHost;

	public PercentLayoutHelper(ViewGroup host) {
	mHost = host;
	}

	/**
	* Helper method to be called from {@link ViewGroup.LayoutParams#setBaseAttributes} override
	* that reads layout_width and layout_height attribute values without throwing an exception if
	* they aren't present.
	*/
	public static void fetchWidthAndHeight(ViewGroup.LayoutParams params, TypedArray array,
	int widthAttr, int heightAttr) {
	params.width = array.getLayoutDimension(widthAttr, 0);
	params.height = array.getLayoutDimension(heightAttr, 0);
	}

	/**
	* Iterates over children and changes their width and height to one calculated from percentage
	* values.
	* @param widthMeasureSpec Width MeasureSpec of the parent ViewGroup.
	* @param heightMeasureSpec Height MeasureSpec of the parent ViewGroup.
	*/
	public void adjustChildren(int widthMeasureSpec, int heightMeasureSpec) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "adjustChildren: " + mHost + " widthMeasureSpec: "
	+ View.MeasureSpec.toString(widthMeasureSpec) + " heightMeasureSpec: "
	+ View.MeasureSpec.toString(heightMeasureSpec));
	}

	int widthHint = View.MeasureSpec.getSize(widthMeasureSpec);
	int heightHint = View.MeasureSpec.getSize(heightMeasureSpec);
	for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
	View view = mHost.getChildAt(i);
	ViewGroup.LayoutParams params = view.getLayoutParams();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "should adjust " + view + " " + params);
	}
	if (params instanceof PercentLayoutParams) {
	PercentLayoutInfo info =
	((PercentLayoutParams) params).getPercentLayoutInfo();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "using " + info);
	}
	if (info != null) {
	if (params instanceof ViewGroup.MarginLayoutParams) {
	info.fillMarginLayoutParams((ViewGroup.MarginLayoutParams) params,
	widthHint, heightHint, info.snapToDimen);
	} else {
	info.fillLayoutParams(params, widthHint, heightHint, info.snapToDimen);
	}
	}
	}
	}
	}

	/**
	* Constructs a PercentLayoutInfo from attributes associated with a View. Call this method from
	* {@code LayoutParams(Context c, AttributeSet attrs)} constructor.
	*/
	public static PercentLayoutInfo getPercentLayoutInfo(Context context,
	AttributeSet attrs) {
	PercentLayoutInfo info = null;
	TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.PercentLayout_Layout);
	float value = array.getFraction(R.styleable.PercentLayout_Layout_layout_widthPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent width: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.widthPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_heightPercent, 1, 1, -1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent height: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.heightPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginPercent, 1, 1, -1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.leftMarginPercent = value;
	info.topMarginPercent = value;
	info.rightMarginPercent = value;
	info.bottomMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginLeftPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent left margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.leftMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginTopPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent top margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.topMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginRightPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent right margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.rightMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginBottomPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent bottom margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.bottomMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginStartPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent start margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.startMarginPercent = value;
	}
	value = array.getFraction(R.styleable.PercentLayout_Layout_layout_marginEndPercent, 1, 1,
	-1f);
	if (value != -1f) {
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.v(TAG, "percent end margin: " + value);
	}
	info = info != null ? info : new PercentLayoutInfo();
	info.endMarginPercent = value;
	}

	int snapToDimen = array.getInt(R.styleable.PercentLayout_Layout_layout_snapToDimen,
	SNAP_TO_NONE);

	if (snapToDimen != SNAP_TO_NONE) {
	info = info != null ? info : new PercentLayoutInfo();
	info.snapToDimen = snapToDimen;
	}

	array.recycle();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "constructed: " + info);
	}
	return info;
	}

	/**
	* Iterates over children and restores their original dimensions that were changed for
	* percentage values. Calling this method only makes sense if you previously called
	* {@link PercentLayoutHelper#adjustChildren(int, int)}.
	*/
	public void restoreOriginalParams() {
	for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
	View view = mHost.getChildAt(i);
	ViewGroup.LayoutParams params = view.getLayoutParams();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "should restore " + view + " " + params);
	}
	if (params instanceof PercentLayoutParams) {
	PercentLayoutInfo info =
	((PercentLayoutParams) params).getPercentLayoutInfo();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "using " + info);
	}
	if (info != null) {
	if (params instanceof ViewGroup.MarginLayoutParams) {
	info.restoreMarginLayoutParams((ViewGroup.MarginLayoutParams) params);
	} else {
	info.restoreLayoutParams(params);
	}
	}
	}
	}
	}

	/**
	* Iterates over children and checks if any of them would like to get more space than it
	* received through the percentage dimension.
	*
	* If you are building a layout that supports percentage dimensions you are encouraged to take
	* advantage of this method. The developer should be able to specify that a child should be
	* remeasured by adding normal dimension attribute with {@code wrap_content} value. For example
	* he might specify child's attributes as {@code app:layout_widthPercent="60%p"} and
	* {@code android:layout_width="wrap_content"}. In this case if the child receives too little
	* space, it will be remeasured with width set to {@code WRAP_CONTENT}.
	*
	* @return True if the measure phase needs to be rerun because one of the children would like
	* to receive more space.
	*/
	public boolean handleMeasuredStateTooSmall() {
	boolean needsSecondMeasure = false;
	for (int i = 0, N = mHost.getChildCount(); i < N; i++) {
	View view = mHost.getChildAt(i);
	ViewGroup.LayoutParams params = view.getLayoutParams();
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "should handle measured state too small " + view + " " + params);
	}
	if (params instanceof PercentLayoutParams) {
	PercentLayoutInfo info =
	((PercentLayoutParams) params).getPercentLayoutInfo();
	if (info != null) {
	if (shouldHandleMeasuredWidthTooSmall(view, info)) {
	needsSecondMeasure = true;
	params.width = ViewGroup.LayoutParams.WRAP_CONTENT;
	}
	if (shouldHandleMeasuredHeightTooSmall(view, info)) {
	needsSecondMeasure = true;
	params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
	}
	}
	}
	}
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "should trigger second measure pass: " + needsSecondMeasure);
	}
	return needsSecondMeasure;
	}

	private static boolean shouldHandleMeasuredWidthTooSmall(View view, PercentLayoutInfo info) {
	int state = ViewCompat.getMeasuredWidthAndState(view) & ViewCompat.MEASURED_STATE_MASK;
	return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.widthPercent >= 0 &&
	info.mPreservedParams.width == ViewGroup.LayoutParams.WRAP_CONTENT;
	}

	private static boolean shouldHandleMeasuredHeightTooSmall(View view, PercentLayoutInfo info) {
	int state = ViewCompat.getMeasuredHeightAndState(view) & ViewCompat.MEASURED_STATE_MASK;
	return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.heightPercent >= 0 &&
	info.mPreservedParams.height == ViewGroup.LayoutParams.WRAP_CONTENT;
	}

	/**
	* Container for information about percentage dimensions and margins. It acts as an extension
	* for {@code LayoutParams}.
	*/
	public static class PercentLayoutInfo {
	public float widthPercent;

	public float heightPercent;

	public float leftMarginPercent;

	public float topMarginPercent;

	public float rightMarginPercent;

	public float bottomMarginPercent;

	public float startMarginPercent;

	public float endMarginPercent;

	public int snapToDimen;

	/* package */ final ViewGroup.MarginLayoutParams mPreservedParams;

	public PercentLayoutInfo() {
	widthPercent = -1f;
	heightPercent = -1f;
	leftMarginPercent = -1f;
	topMarginPercent = -1f;
	rightMarginPercent = -1f;
	bottomMarginPercent = -1f;
	startMarginPercent = -1f;
	endMarginPercent = -1f;
	mPreservedParams = new ViewGroup.MarginLayoutParams(0, 0);
	}

	/**
	* Fills {@code ViewGroup.LayoutParams} dimensions based on percentage values.
	*/
	public void fillLayoutParams(ViewGroup.LayoutParams params, int widthHint,
	int heightHint, int snapToDimen) {
	// Preserve the original layout params, so we can restore them after the measure step.
	mPreservedParams.width = params.width;
	mPreservedParams.height = params.height;

	if (widthPercent >= 0) {
	params.width = (int) (widthHint * widthPercent);
	}

	if (heightPercent >= 0) {
	params.height = (int) (heightHint * heightPercent);
	}

	switch (snapToDimen) {
	case SNAP_TO_HEIGHT:
	params.width = params.height;
	break;
	case SNAP_TO_WIDTH:
	params.height = params.width;
	break;
	}

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "after fillLayoutParams: (" + params.width + ", " + params.height + ")");
	}
	}

	/**
	* Fills {@code ViewGroup.MarginLayoutParams} dimensions and margins based on percentage
	* values.
	*/
	public void fillMarginLayoutParams(ViewGroup.MarginLayoutParams params, int widthHint,
	int heightHint, int snapToDimen) {
	fillLayoutParams(params, widthHint, heightHint, snapToDimen);

	// Preserver the original margins, so we can restore them after the measure step.
	mPreservedParams.leftMargin = params.leftMargin;
	mPreservedParams.topMargin = params.topMargin;
	mPreservedParams.rightMargin = params.rightMargin;
	mPreservedParams.bottomMargin = params.bottomMargin;
	MarginLayoutParamsCompat.setMarginStart(mPreservedParams,
	MarginLayoutParamsCompat.getMarginStart(params));
	MarginLayoutParamsCompat.setMarginEnd(mPreservedParams,
	MarginLayoutParamsCompat.getMarginEnd(params));

	if (leftMarginPercent >= 0) {
	params.leftMargin = (int) (widthHint * leftMarginPercent);
	}
	if (topMarginPercent >= 0) {
	params.topMargin = (int) (heightHint * topMarginPercent);
	}
	if (rightMarginPercent >= 0) {
	params.rightMargin = (int) (widthHint * rightMarginPercent);
	}
	if (bottomMarginPercent >= 0) {
	params.bottomMargin = (int) (heightHint * bottomMarginPercent);
	}
	if (startMarginPercent >= 0) {
	MarginLayoutParamsCompat.setMarginStart(params,
	(int) (widthHint * startMarginPercent));
	}
	if (endMarginPercent >= 0) {
	MarginLayoutParamsCompat.setMarginEnd(params,
	(int) (widthHint * endMarginPercent));
	}
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "after fillMarginLayoutParams: (" + params.width + ", " + params.height
	+ ")");
	}
	}

	@Override
	public String toString() {
	return String.format("PercentLayoutInformation width: %f height %f, margins (%f, %f, "
	+ " %f, %f, %f, %f)", widthPercent, heightPercent, leftMarginPercent,
	topMarginPercent, rightMarginPercent, bottomMarginPercent, startMarginPercent,
	endMarginPercent);

	}

	/**
	* Restores original dimensions and margins after they were changed for percentage based
	* values. Calling this method only makes sense if you previously called
	* {@link PercentLayoutHelper.PercentLayoutInfo#fillMarginLayoutParams}.
	*/
	public void restoreMarginLayoutParams(ViewGroup.MarginLayoutParams params) {
	restoreLayoutParams(params);
	params.leftMargin = mPreservedParams.leftMargin;
	params.topMargin = mPreservedParams.topMargin;
	params.rightMargin = mPreservedParams.rightMargin;
	params.bottomMargin = mPreservedParams.bottomMargin;
	MarginLayoutParamsCompat.setMarginStart(params,
	MarginLayoutParamsCompat.getMarginStart(mPreservedParams));
	MarginLayoutParamsCompat.setMarginEnd(params,
	MarginLayoutParamsCompat.getMarginEnd(mPreservedParams));
	}

	/**
	* Restores original dimensions after they were changed for percentage based values. Calling
	* this method only makes sense if you previously called
	* {@link PercentLayoutHelper.PercentLayoutInfo#fillLayoutParams}.
	*/
	public void restoreLayoutParams(ViewGroup.LayoutParams params) {
	params.width = mPreservedParams.width;
	params.height = mPreservedParams.height;
	}
	}

	/**
	* If a layout wants to support percentage based dimensions and use this helper class, its
	* {@code LayoutParams} subclass must implement this interface.
	*
	* Your {@code LayoutParams} subclass should contain an instance of {@code PercentLayoutInfo}
	* and the implementation of this interface should be a simple accessor.
	*/
	public interface PercentLayoutParams {
	PercentLayoutInfo getPercentLayoutInfo();
	}
	}