10 | {
11 | public ApplicationTest()
12 | {
13 | super(Application.class);
14 | }
15 | }
--------------------------------------------------------------------------------
/percent-support-extends/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
3 |
4 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/gen/com/zhy/android/percent/support/BuildConfig.java:
--------------------------------------------------------------------------------
1 | /*___Generated_by_IDEA___*/
2 |
3 | package com.zhy.android.percent.support;
4 |
5 | /* This stub is only used by the IDE. It is NOT the BuildConfig class actually packed into the APK */
6 | public final class BuildConfig {
7 | public final static boolean DEBUG = Boolean.parseBoolean(null);
8 | }
--------------------------------------------------------------------------------
/percent-support-extends/src/main/gen/com/zhy/android/percent/support/Manifest.java:
--------------------------------------------------------------------------------
1 | /*___Generated_by_IDEA___*/
2 |
3 | package com.zhy.android.percent.support;
4 |
5 | /* This stub is only used by the IDE. It is NOT the Manifest class actually packed into the APK */
6 | public final class Manifest {
7 | }
--------------------------------------------------------------------------------
/percent-support-extends/src/main/gen/com/zhy/android/percent/support/R.java:
--------------------------------------------------------------------------------
1 | /*___Generated_by_IDEA___*/
2 |
3 | package com.zhy.android.percent.support;
4 |
5 | /* This stub is only used by the IDE. It is NOT the R class actually packed into the APK */
6 | public final class R {
7 | }
--------------------------------------------------------------------------------
/percent-support-extends/src/main/java/com/zhy/android/percent/support/PercentFrameLayout.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.zhy.android.percent.support;
18 |
19 | import android.content.Context;
20 | import android.content.res.TypedArray;
21 | import android.util.AttributeSet;
22 | import android.view.ViewGroup;
23 | import android.widget.FrameLayout;
24 |
25 | /**
26 | * Subclass of {@link FrameLayout} that supports percentage based dimensions and
27 | * margins.
28 | *
29 | * You can specify dimension or a margin of child by using attributes with "Percent" suffix. Follow
30 | * this example:
31 | *
32 | *
33 | * <android.support.percent.PercentFrameLayout
34 | * xmlns:android="http://schemas.android.com/apk/res/android"
35 | * xmlns:app="http://schemas.android.com/apk/res-auto"
36 | * android:layout_width="match_parent"
37 | * android:layout_height="match_parent"/>
38 | * <ImageView
39 | * app:layout_widthPercent="50%"
40 | * app:layout_heightPercent="50%"
41 | * app:layout_marginTopPercent="25%"
42 | * app:layout_marginLeftPercent="25%"/>
43 | * </android.support.percent.PercentFrameLayout/>
44 | *
45 | *
46 | * The attributes that you can use are:
47 | *
48 | * - {@code layout_widthPercent}
49 | *
- {@code layout_heightPercent}
50 | *
- {@code layout_marginPercent}
51 | *
- {@code layout_marginLeftPercent}
52 | *
- {@code layout_marginTopPercent}
53 | *
- {@code layout_marginRightPercent}
54 | *
- {@code layout_marginBottomPercent}
55 | *
- {@code layout_marginStartPercent}
56 | *
- {@code layout_marginEndPercent}
57 | *
58 | *
59 | * It is not necessary to specify {@code layout_width/height} if you specify {@code
60 | * layout_widthPercent.} However, if you want the view to be able to take up more space than what
61 | * percentage value permits, you can add {@code layout_width/height="wrap_content"}. In that case
62 | * if the percentage size is too small for the View's content, it will be resized using
63 | * {@code wrap_content} rule.
64 | */
65 | public class PercentFrameLayout extends FrameLayout {
66 | private final PercentLayoutHelper mHelper = new PercentLayoutHelper(this);
67 |
68 | public PercentFrameLayout(Context context) {
69 | super(context);
70 | }
71 |
72 | public PercentFrameLayout(Context context, AttributeSet attrs) {
73 | super(context, attrs);
74 | }
75 |
76 | public PercentFrameLayout(Context context, AttributeSet attrs, int defStyleAttr) {
77 | super(context, attrs, defStyleAttr);
78 | }
79 |
80 | @Override
81 | public LayoutParams generateLayoutParams(AttributeSet attrs) {
82 | return new LayoutParams(getContext(), attrs);
83 | }
84 |
85 | @Override
86 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
87 | mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
88 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
89 | if (mHelper.handleMeasuredStateTooSmall()) {
90 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
91 | }
92 | }
93 |
94 | @Override
95 | protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
96 | super.onLayout(changed, left, top, right, bottom);
97 | mHelper.restoreOriginalParams();
98 | }
99 |
100 | public static class LayoutParams extends FrameLayout.LayoutParams
101 | implements PercentLayoutHelper.PercentLayoutParams {
102 | private PercentLayoutHelper.PercentLayoutInfo mPercentLayoutInfo;
103 |
104 | public LayoutParams(Context c, AttributeSet attrs) {
105 | super(c, attrs);
106 | mPercentLayoutInfo = PercentLayoutHelper.getPercentLayoutInfo(c, attrs);
107 | }
108 |
109 | public LayoutParams(int width, int height) {
110 | super(width, height);
111 | }
112 |
113 | public LayoutParams(int width, int height, int gravity) {
114 | super(width, height, gravity);
115 | }
116 |
117 | public LayoutParams(ViewGroup.LayoutParams source) {
118 | super(source);
119 | }
120 |
121 | public LayoutParams(MarginLayoutParams source) {
122 | super(source);
123 | }
124 |
125 | public LayoutParams(FrameLayout.LayoutParams source) {
126 | super((MarginLayoutParams) source);
127 | gravity = source.gravity;
128 | }
129 |
130 | public LayoutParams(LayoutParams source) {
131 | this((FrameLayout.LayoutParams) source);
132 | mPercentLayoutInfo = source.mPercentLayoutInfo;
133 | }
134 |
135 | @Override
136 | public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo() {
137 | return mPercentLayoutInfo;
138 | }
139 |
140 | @Override
141 | protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
142 | PercentLayoutHelper.fetchWidthAndHeight(this, a, widthAttr, heightAttr);
143 | }
144 | }
145 | }
146 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/java/com/zhy/android/percent/support/PercentLayoutHelper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.zhy.android.percent.support;
18 |
19 | import android.content.Context;
20 | import android.content.res.TypedArray;
21 | import android.support.annotation.NonNull;
22 | import android.support.v4.view.MarginLayoutParamsCompat;
23 | import android.support.v4.view.ViewCompat;
24 | import android.util.AttributeSet;
25 | import android.util.DisplayMetrics;
26 | import android.util.Log;
27 | import android.util.TypedValue;
28 | import android.view.View;
29 | import android.view.ViewGroup;
30 | import android.view.WindowManager;
31 | import android.widget.TextView;
32 |
33 | import java.lang.reflect.InvocationTargetException;
34 | import java.lang.reflect.Method;
35 | import java.util.regex.Matcher;
36 | import java.util.regex.Pattern;
37 |
38 |
39 | /**
40 | * Helper for layouts that want to support percentage based dimensions.
41 | *
42 | * This class collects utility methods that are involved in extracting percentage based dimension
43 | * attributes and applying them to ViewGroup's children. If you would like to implement a layout
44 | * that supports percentage based dimensions, you need to take several steps:
45 | *
46 | *
47 | * - You need a {@link ViewGroup.LayoutParams} subclass in your ViewGroup that implements
48 | * {@link com.zhy.android.percent.support.PercentLayoutHelper.PercentLayoutParams}.
49 | *
- In your {@code LayoutParams(Context c, AttributeSet attrs)} constructor create an instance
50 | * of {@link PercentLayoutHelper.PercentLayoutInfo} by calling
51 | * {@link PercentLayoutHelper#getPercentLayoutInfo(Context, AttributeSet)}. Return this
52 | * object from {@code public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo()}
53 | * method that you implemented for {@link com.zhy.android.percent.support.PercentLayoutHelper.PercentLayoutParams} interface.
54 | *
- Override
55 | * {@link ViewGroup.LayoutParams#setBaseAttributes(TypedArray, int, int)}
56 | * with a single line implementation {@code PercentLayoutHelper.fetchWidthAndHeight(this, a,
57 | * widthAttr, heightAttr);}
58 | *
- In your ViewGroup override {@link ViewGroup#generateLayoutParams(AttributeSet)} to return
59 | * your LayoutParams.
60 | *
- In your {@link ViewGroup#onMeasure(int, int)} override, you need to implement following
61 | * pattern:
62 | *
63 | * protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
64 | * mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
65 | * super.onMeasure(widthMeasureSpec, heightMeasureSpec);
66 | * if (mHelper.handleMeasuredStateTooSmall()) {
67 | * super.onMeasure(widthMeasureSpec, heightMeasureSpec);
68 | * }
69 | * }
70 | *
71 | * - In your {@link ViewGroup#onLayout(boolean, int, int, int, int)} override, you need to
72 | * implement following pattern:
73 | *
74 | * protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
75 | * super.onLayout(changed, left, top, right, bottom);
76 | * mHelper.restoreOriginalParams();
77 | * }
78 | *
79 | *
80 | */
81 | public class PercentLayoutHelper
82 | {
83 | private static final String TAG = "PercentLayout";
84 |
85 | private final ViewGroup mHost;
86 |
87 | private static int mWidthScreen;
88 | private static int mHeightScreen;
89 |
90 | public PercentLayoutHelper(ViewGroup host)
91 | {
92 | mHost = host;
93 | getScreenSize();
94 | }
95 |
96 | private void getScreenSize()
97 | {
98 | WindowManager wm = (WindowManager) mHost.getContext().getSystemService(Context.WINDOW_SERVICE);
99 | DisplayMetrics outMetrics = new DisplayMetrics();
100 | wm.getDefaultDisplay().getMetrics(outMetrics);
101 | mWidthScreen = outMetrics.widthPixels;
102 | mHeightScreen = outMetrics.heightPixels;
103 | }
104 |
105 |
106 | /**
107 | * Helper method to be called from {@link ViewGroup.LayoutParams#setBaseAttributes} override
108 | * that reads layout_width and layout_height attribute values without throwing an exception if
109 | * they aren't present.
110 | */
111 | public static void fetchWidthAndHeight(ViewGroup.LayoutParams params, TypedArray array,
112 | int widthAttr, int heightAttr)
113 | {
114 | params.width = array.getLayoutDimension(widthAttr, 0);
115 | params.height = array.getLayoutDimension(heightAttr, 0);
116 | }
117 |
118 | /**
119 | * Iterates over children and changes their width and height to one calculated from percentage
120 | * values.
121 | *
122 | * @param widthMeasureSpec Width MeasureSpec of the parent ViewGroup.
123 | * @param heightMeasureSpec Height MeasureSpec of the parent ViewGroup.
124 | */
125 | public void adjustChildren(int widthMeasureSpec, int heightMeasureSpec)
126 | {
127 | if (Log.isLoggable(TAG, Log.DEBUG))
128 | {
129 | Log.d(TAG, "adjustChildren: " + mHost + " widthMeasureSpec: "
130 | + View.MeasureSpec.toString(widthMeasureSpec) + " heightMeasureSpec: "
131 | + View.MeasureSpec.toString(heightMeasureSpec));
132 | }
133 | int widthHint = View.MeasureSpec.getSize(widthMeasureSpec);
134 | int heightHint = View.MeasureSpec.getSize(heightMeasureSpec);
135 |
136 | if (Log.isLoggable(TAG, Log.DEBUG))
137 | Log.d(TAG, "widthHint = " + widthHint + " , heightHint = " + heightHint);
138 |
139 | for (int i = 0, N = mHost.getChildCount(); i < N; i++)
140 | {
141 | View view = mHost.getChildAt(i);
142 | ViewGroup.LayoutParams params = view.getLayoutParams();
143 |
144 | if (Log.isLoggable(TAG, Log.DEBUG))
145 | {
146 | Log.d(TAG, "should adjust " + view + " " + params);
147 | }
148 |
149 | if (params instanceof PercentLayoutParams)
150 | {
151 | PercentLayoutInfo info =
152 | ((PercentLayoutParams) params).getPercentLayoutInfo();
153 | if (Log.isLoggable(TAG, Log.DEBUG))
154 | {
155 | Log.d(TAG, "using " + info);
156 | }
157 | if (info != null)
158 | {
159 | supportTextSize(widthHint, heightHint, view, info);
160 | supportPadding(widthHint, heightHint, view, info);
161 | supportMinOrMaxDimesion(widthHint, heightHint, view, info);
162 |
163 | if (params instanceof ViewGroup.MarginLayoutParams)
164 | {
165 | info.fillMarginLayoutParams((ViewGroup.MarginLayoutParams) params,
166 | widthHint, heightHint);
167 | } else
168 | {
169 | info.fillLayoutParams(params, widthHint, heightHint);
170 | }
171 | }
172 | }
173 | }
174 |
175 |
176 | }
177 |
178 | private void supportPadding(int widthHint, int heightHint, View view, PercentLayoutInfo info)
179 | {
180 | int left = view.getPaddingLeft(), right = view.getPaddingRight(), top = view.getPaddingTop(), bottom = view.getPaddingBottom();
181 | PercentLayoutInfo.PercentVal percentVal = info.paddingLeftPercent;
182 | if (percentVal != null)
183 | {
184 | int base = getBaseByModeAndVal(widthHint, heightHint, percentVal.basemode);
185 | left = (int) (base * percentVal.percent);
186 | }
187 | percentVal = info.paddingRightPercent;
188 | if (percentVal != null)
189 | {
190 | int base = getBaseByModeAndVal(widthHint, heightHint, percentVal.basemode);
191 | right = (int) (base * percentVal.percent);
192 | }
193 |
194 | percentVal = info.paddingTopPercent;
195 | if (percentVal != null)
196 | {
197 | int base = getBaseByModeAndVal(widthHint, heightHint, percentVal.basemode);
198 | top = (int) (base * percentVal.percent);
199 | }
200 |
201 | percentVal = info.paddingBottomPercent;
202 | if (percentVal != null)
203 | {
204 | int base = getBaseByModeAndVal(widthHint, heightHint, percentVal.basemode);
205 | bottom = (int) (base * percentVal.percent);
206 | }
207 | view.setPadding(left, top, right, bottom);
208 |
209 |
210 | }
211 |
212 | private void supportMinOrMaxDimesion(int widthHint, int heightHint, View view, PercentLayoutInfo info)
213 | {
214 | try
215 | {
216 | Class clazz = view.getClass();
217 | invokeMethod("setMaxWidth", widthHint, heightHint, view, clazz, info.maxWidthPercent);
218 | invokeMethod("setMaxHeight", widthHint, heightHint, view, clazz, info.maxHeightPercent);
219 | invokeMethod("setMinWidth", widthHint, heightHint, view, clazz, info.minWidthPercent);
220 | invokeMethod("setMinHeight", widthHint, heightHint, view, clazz, info.minHeightPercent);
221 |
222 | } catch (NoSuchMethodException e)
223 | {
224 | e.printStackTrace();
225 | } catch (InvocationTargetException e)
226 | {
227 | e.printStackTrace();
228 | } catch (IllegalAccessException e)
229 | {
230 | e.printStackTrace();
231 | }
232 |
233 | }
234 |
235 | private void invokeMethod(String methodName, int widthHint, int heightHint, View view, Class clazz, PercentLayoutInfo.PercentVal percentVal) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException
236 | {
237 | if (Log.isLoggable(TAG, Log.DEBUG))
238 | Log.d(TAG, methodName + " ==> " + percentVal);
239 | if (percentVal != null)
240 | {
241 | Method setMaxWidthMethod = clazz.getMethod(methodName, int.class);
242 | setMaxWidthMethod.setAccessible(true);
243 | int base = getBaseByModeAndVal(widthHint, heightHint, percentVal.basemode);
244 | setMaxWidthMethod.invoke(view, (int) (base * percentVal.percent));
245 | }
246 | }
247 |
248 | private void supportTextSize(int widthHint, int heightHint, View view, PercentLayoutInfo info)
249 | {
250 | //textsize percent support
251 |
252 | PercentLayoutInfo.PercentVal textSizePercent = info.textSizePercent;
253 | if (textSizePercent == null) return;
254 |
255 | int base = getBaseByModeAndVal(widthHint, heightHint, textSizePercent.basemode);
256 | float textSize = (int) (base * textSizePercent.percent);
257 |
258 | //Button 和 EditText 是TextView的子类
259 | if (view instanceof TextView)
260 | {
261 | ((TextView) view).setTextSize(TypedValue.COMPLEX_UNIT_PX, textSize);
262 | }
263 | }
264 |
265 | private static int getBaseByModeAndVal(int widthHint, int heightHint, PercentLayoutInfo.BASEMODE basemode)
266 | {
267 | switch (basemode)
268 | {
269 | case BASE_HEIGHT:
270 | return heightHint;
271 | case BASE_WIDTH:
272 | return widthHint;
273 | case BASE_SCREEN_WIDTH:
274 | return mWidthScreen;
275 | case BASE_SCREEN_HEIGHT:
276 | return mHeightScreen;
277 | }
278 | return 0;
279 | }
280 |
281 |
282 | /**
283 | * Constructs a PercentLayoutInfo from attributes associated with a View. Call this method from
284 | * {@code LayoutParams(Context c, AttributeSet attrs)} constructor.
285 | */
286 | public static PercentLayoutInfo getPercentLayoutInfo(Context context,
287 | AttributeSet attrs)
288 | {
289 | PercentLayoutInfo info = null;
290 | TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.PercentLayout_Layout);
291 |
292 | info = setWidthAndHeightVal(array, info);
293 |
294 | info = setMarginRelatedVal(array, info);
295 |
296 | info = setTextSizeSupportVal(array, info);
297 |
298 | info = setMinMaxWidthHeightRelatedVal(array, info);
299 |
300 | info = setPaddingRelatedVal(array, info);
301 |
302 |
303 | array.recycle();
304 |
305 | if (Log.isLoggable(TAG, Log.DEBUG))
306 | {
307 | Log.d(TAG, "constructed: " + info);
308 | }
309 | return info;
310 | }
311 |
312 | private static PercentLayoutInfo setWidthAndHeightVal(TypedArray array, PercentLayoutInfo info)
313 | {
314 | PercentLayoutInfo.PercentVal percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_widthPercent, true);
315 | if (percentVal != null)
316 | {
317 | if (Log.isLoggable(TAG, Log.VERBOSE))
318 | {
319 | Log.v(TAG, "percent width: " + percentVal.percent);
320 | }
321 | info = checkForInfoExists(info);
322 | info.widthPercent = percentVal;
323 | }
324 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_heightPercent, false);
325 |
326 | if (percentVal != null)
327 | {
328 | if (Log.isLoggable(TAG, Log.VERBOSE))
329 | {
330 | Log.v(TAG, "percent height: " + percentVal.percent);
331 | }
332 | info = checkForInfoExists(info);
333 | info.heightPercent = percentVal;
334 | }
335 |
336 | return info;
337 | }
338 |
339 | private static PercentLayoutInfo setTextSizeSupportVal(TypedArray array, PercentLayoutInfo info)
340 | {
341 | //textSizePercent 默认以高度作为基准
342 | PercentLayoutInfo.PercentVal percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_textSizePercent, false);
343 | if (percentVal != null)
344 | {
345 | if (Log.isLoggable(TAG, Log.VERBOSE))
346 | {
347 | Log.v(TAG, "percent text size: " + percentVal.percent);
348 | }
349 | info = checkForInfoExists(info);
350 | info.textSizePercent = percentVal;
351 | }
352 |
353 | return info;
354 | }
355 |
356 | private static PercentLayoutInfo setMinMaxWidthHeightRelatedVal(TypedArray array, PercentLayoutInfo info)
357 | {
358 | //maxWidth
359 | PercentLayoutInfo.PercentVal percentVal = getPercentVal(array,
360 | R.styleable.PercentLayout_Layout_layout_maxWidthPercent,
361 | true);
362 | if (percentVal != null)
363 | {
364 | info = checkForInfoExists(info);
365 | info.maxWidthPercent = percentVal;
366 | }
367 | //maxHeight
368 | percentVal = getPercentVal(array,
369 | R.styleable.PercentLayout_Layout_layout_maxHeightPercent,
370 | false);
371 | if (percentVal != null)
372 | {
373 | info = checkForInfoExists(info);
374 | info.maxHeightPercent = percentVal;
375 | }
376 | //minWidth
377 | percentVal = getPercentVal(array,
378 | R.styleable.PercentLayout_Layout_layout_minWidthPercent,
379 | true);
380 | if (percentVal != null)
381 | {
382 | info = checkForInfoExists(info);
383 | info.minWidthPercent = percentVal;
384 | }
385 | //minHeight
386 | percentVal = getPercentVal(array,
387 | R.styleable.PercentLayout_Layout_layout_minHeightPercent,
388 | false);
389 | if (percentVal != null)
390 | {
391 | info = checkForInfoExists(info);
392 | info.minHeightPercent = percentVal;
393 | }
394 |
395 | return info;
396 | }
397 |
398 | private static PercentLayoutInfo setMarginRelatedVal(TypedArray array, PercentLayoutInfo info)
399 | {
400 | //默认margin参考宽度
401 | PercentLayoutInfo.PercentVal percentVal =
402 | getPercentVal(array,
403 | R.styleable.PercentLayout_Layout_layout_marginPercent,
404 | true);
405 |
406 | if (percentVal != null)
407 | {
408 | if (Log.isLoggable(TAG, Log.VERBOSE))
409 | {
410 | Log.v(TAG, "percent margin: " + percentVal.percent);
411 | }
412 | info = checkForInfoExists(info);
413 | info.leftMarginPercent = percentVal;
414 | info.topMarginPercent = percentVal;
415 | info.rightMarginPercent = percentVal;
416 | info.bottomMarginPercent = percentVal;
417 | }
418 |
419 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginLeftPercent, true);
420 | if (percentVal != null)
421 | {
422 | if (Log.isLoggable(TAG, Log.VERBOSE))
423 | {
424 | Log.v(TAG, "percent left margin: " + percentVal.percent);
425 | }
426 | info = checkForInfoExists(info);
427 | info.leftMarginPercent = percentVal;
428 | }
429 |
430 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginTopPercent, false);
431 | if (percentVal != null)
432 | {
433 | if (Log.isLoggable(TAG, Log.VERBOSE))
434 | {
435 | Log.v(TAG, "percent top margin: " + percentVal.percent);
436 | }
437 | info = checkForInfoExists(info);
438 | info.topMarginPercent = percentVal;
439 | }
440 |
441 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginRightPercent, true);
442 | if (percentVal != null)
443 | {
444 | if (Log.isLoggable(TAG, Log.VERBOSE))
445 | {
446 | Log.v(TAG, "percent right margin: " + percentVal.percent);
447 | }
448 | info = checkForInfoExists(info);
449 | info.rightMarginPercent = percentVal;
450 | }
451 |
452 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginBottomPercent, false);
453 | if (percentVal != null)
454 | {
455 | if (Log.isLoggable(TAG, Log.VERBOSE))
456 | {
457 | Log.v(TAG, "percent bottom margin: " + percentVal.percent);
458 | }
459 | info = checkForInfoExists(info);
460 | info.bottomMarginPercent = percentVal;
461 | }
462 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginStartPercent, true);
463 | if (percentVal != null)
464 | {
465 | if (Log.isLoggable(TAG, Log.VERBOSE))
466 | {
467 | Log.v(TAG, "percent start margin: " + percentVal.percent);
468 | }
469 | info = checkForInfoExists(info);
470 | info.startMarginPercent = percentVal;
471 | }
472 |
473 | percentVal = getPercentVal(array, R.styleable.PercentLayout_Layout_layout_marginEndPercent, true);
474 | if (percentVal != null)
475 | {
476 | if (Log.isLoggable(TAG, Log.VERBOSE))
477 | {
478 | Log.v(TAG, "percent end margin: " + percentVal.percent);
479 | }
480 | info = checkForInfoExists(info);
481 | info.endMarginPercent = percentVal;
482 | }
483 |
484 | return info;
485 | }
486 |
487 | /**
488 | * 设置paddingPercent相关属性
489 | *
490 | * @param array
491 | * @param info
492 | */
493 | private static PercentLayoutInfo setPaddingRelatedVal(TypedArray array, PercentLayoutInfo info)
494 | {
495 | //默认padding以宽度为标准
496 | PercentLayoutInfo.PercentVal percentVal = getPercentVal(array,
497 | R.styleable.PercentLayout_Layout_layout_paddingPercent,
498 | true);
499 | if (percentVal != null)
500 | {
501 | info = checkForInfoExists(info);
502 | info.paddingLeftPercent = percentVal;
503 | info.paddingRightPercent = percentVal;
504 | info.paddingBottomPercent = percentVal;
505 | info.paddingTopPercent = percentVal;
506 | }
507 |
508 |
509 | percentVal = getPercentVal(array,
510 | R.styleable.PercentLayout_Layout_layout_paddingLeftPercent,
511 | true);
512 | if (percentVal != null)
513 | {
514 | info = checkForInfoExists(info);
515 | info.paddingLeftPercent = percentVal;
516 | }
517 |
518 | percentVal = getPercentVal(array,
519 | R.styleable.PercentLayout_Layout_layout_paddingRightPercent,
520 | true);
521 | if (percentVal != null)
522 | {
523 | info = checkForInfoExists(info);
524 | info.paddingRightPercent = percentVal;
525 | }
526 |
527 | percentVal = getPercentVal(array,
528 | R.styleable.PercentLayout_Layout_layout_paddingTopPercent,
529 | true);
530 | if (percentVal != null)
531 | {
532 | info = checkForInfoExists(info);
533 | info.paddingTopPercent = percentVal;
534 | }
535 |
536 | percentVal = getPercentVal(array,
537 | R.styleable.PercentLayout_Layout_layout_paddingBottomPercent,
538 | true);
539 | if (percentVal != null)
540 | {
541 | info = checkForInfoExists(info);
542 | info.paddingBottomPercent = percentVal;
543 | }
544 |
545 | return info;
546 | }
547 |
548 | private static PercentLayoutInfo.PercentVal getPercentVal(TypedArray array, int index, boolean baseWidth)
549 | {
550 | String sizeStr = array.getString(index);
551 | PercentLayoutInfo.PercentVal percentVal = getPercentVal(sizeStr, baseWidth);
552 | return percentVal;
553 | }
554 |
555 |
556 | @NonNull
557 | private static PercentLayoutInfo checkForInfoExists(PercentLayoutInfo info)
558 | {
559 | info = info != null ? info : new PercentLayoutInfo();
560 | return info;
561 | }
562 |
563 |
564 | private static final String REGEX_PERCENT = "^(([0-9]+)([.]([0-9]+))?|([.]([0-9]+))?)%([s]?[wh]?)$";
565 |
566 | /**
567 | * widthStr to PercentVal
568 | *
569 | * eg: 35%w => new PercentVal(35, true)
570 | *
571 | * @param percentStr
572 | * @param isOnWidth
573 | * @return
574 | */
575 | private static PercentLayoutInfo.PercentVal getPercentVal(String percentStr, boolean isOnWidth)
576 | {
577 | //valid param
578 | if (percentStr == null)
579 | {
580 | return null;
581 | }
582 | Pattern p = Pattern.compile(REGEX_PERCENT);
583 | Matcher matcher = p.matcher(percentStr);
584 | if (!matcher.matches())
585 | {
586 | throw new RuntimeException("the value of layout_xxxPercent invalid! ==>" + percentStr);
587 | }
588 | int len = percentStr.length();
589 | //extract the float value
590 | String floatVal = matcher.group(1);
591 | String lastAlpha = percentStr.substring(len - 1);
592 |
593 | float percent = Float.parseFloat(floatVal) / 100f;
594 |
595 | PercentLayoutInfo.PercentVal percentVal = new PercentLayoutInfo.PercentVal();
596 | percentVal.percent = percent;
597 | if (percentStr.endsWith(PercentLayoutInfo.BASEMODE.SW))
598 | {
599 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_SCREEN_WIDTH;
600 | } else if (percentStr.endsWith(PercentLayoutInfo.BASEMODE.SH))
601 | {
602 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_SCREEN_HEIGHT;
603 | } else if (percentStr.endsWith(PercentLayoutInfo.BASEMODE.PERCENT))
604 | {
605 | if (isOnWidth)
606 | {
607 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_WIDTH;
608 | } else
609 | {
610 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_HEIGHT;
611 | }
612 | } else if (percentStr.endsWith(PercentLayoutInfo.BASEMODE.W))
613 | {
614 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_WIDTH;
615 | } else if (percentStr.endsWith(PercentLayoutInfo.BASEMODE.H))
616 | {
617 | percentVal.basemode = PercentLayoutInfo.BASEMODE.BASE_HEIGHT;
618 | } else
619 | {
620 | throw new IllegalArgumentException("the " + percentStr + " must be endWith [%|w|h|sw|sh]");
621 | }
622 |
623 | return percentVal;
624 | }
625 |
626 | /**
627 | * Iterates over children and restores their original dimensions that were changed for
628 | * percentage values. Calling this method only makes sense if you previously called
629 | * {@link PercentLayoutHelper#adjustChildren(int, int)}.
630 | */
631 |
632 | public void restoreOriginalParams()
633 | {
634 | for (int i = 0, N = mHost.getChildCount(); i < N; i++)
635 | {
636 | View view = mHost.getChildAt(i);
637 | ViewGroup.LayoutParams params = view.getLayoutParams();
638 | if (Log.isLoggable(TAG, Log.DEBUG))
639 | {
640 | Log.d(TAG, "should restore " + view + " " + params);
641 | }
642 | if (params instanceof PercentLayoutParams)
643 | {
644 | PercentLayoutInfo info =
645 | ((PercentLayoutParams) params).getPercentLayoutInfo();
646 | if (Log.isLoggable(TAG, Log.DEBUG))
647 | {
648 | Log.d(TAG, "using " + info);
649 | }
650 | if (info != null)
651 | {
652 | if (params instanceof ViewGroup.MarginLayoutParams)
653 | {
654 | info.restoreMarginLayoutParams((ViewGroup.MarginLayoutParams) params);
655 | } else
656 | {
657 | info.restoreLayoutParams(params);
658 | }
659 | }
660 | }
661 | }
662 | }
663 |
664 | /**
665 | * Iterates over children and checks if any of them would like to get more space than it
666 | * received through the percentage dimension.
667 | *
668 | * If you are building a layout that supports percentage dimensions you are encouraged to take
669 | * advantage of this method. The developer should be able to specify that a child should be
670 | * remeasured by adding normal dimension attribute with {@code wrap_content} value. For example
671 | * he might specify child's attributes as {@code app:layout_widthPercent="60%p"} and
672 | * {@code android:layout_width="wrap_content"}. In this case if the child receives too little
673 | * space, it will be remeasured with width set to {@code WRAP_CONTENT}.
674 | *
675 | * @return True if the measure phase needs to be rerun because one of the children would like
676 | * to receive more space.
677 | */
678 | public boolean handleMeasuredStateTooSmall()
679 | {
680 | boolean needsSecondMeasure = false;
681 | for (int i = 0, N = mHost.getChildCount(); i < N; i++)
682 | {
683 | View view = mHost.getChildAt(i);
684 | ViewGroup.LayoutParams params = view.getLayoutParams();
685 | if (Log.isLoggable(TAG, Log.DEBUG))
686 | {
687 | Log.d(TAG, "should handle measured state too small " + view + " " + params);
688 | }
689 | if (params instanceof PercentLayoutParams)
690 | {
691 | PercentLayoutInfo info =
692 | ((PercentLayoutParams) params).getPercentLayoutInfo();
693 | if (info != null)
694 | {
695 | if (shouldHandleMeasuredWidthTooSmall(view, info))
696 | {
697 | needsSecondMeasure = true;
698 | params.width = ViewGroup.LayoutParams.WRAP_CONTENT;
699 | }
700 | if (shouldHandleMeasuredHeightTooSmall(view, info))
701 | {
702 | needsSecondMeasure = true;
703 | params.height = ViewGroup.LayoutParams.WRAP_CONTENT;
704 | }
705 | }
706 | }
707 | }
708 | if (Log.isLoggable(TAG, Log.DEBUG))
709 | {
710 | Log.d(TAG, "should trigger second measure pass: " + needsSecondMeasure);
711 | }
712 | return needsSecondMeasure;
713 | }
714 |
715 | private static boolean shouldHandleMeasuredWidthTooSmall(View view, PercentLayoutInfo info)
716 | {
717 | int state = ViewCompat.getMeasuredWidthAndState(view) & ViewCompat.MEASURED_STATE_MASK;
718 | if (info == null || info.widthPercent == null)
719 | {
720 | return false;
721 | }
722 | return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.widthPercent.percent >= 0 &&
723 | info.mPreservedParams.width == ViewGroup.LayoutParams.WRAP_CONTENT;
724 | }
725 |
726 | private static boolean shouldHandleMeasuredHeightTooSmall(View view, PercentLayoutInfo info)
727 | {
728 | int state = ViewCompat.getMeasuredHeightAndState(view) & ViewCompat.MEASURED_STATE_MASK;
729 | if (info == null || info.heightPercent == null)
730 | {
731 | return false;
732 | }
733 | return state == ViewCompat.MEASURED_STATE_TOO_SMALL && info.heightPercent.percent >= 0 &&
734 | info.mPreservedParams.height == ViewGroup.LayoutParams.WRAP_CONTENT;
735 | }
736 |
737 |
738 | /**
739 | * Container for information about percentage dimensions and margins. It acts as an extension
740 | * for {@code LayoutParams}.
741 | */
742 | public static class PercentLayoutInfo
743 | {
744 |
745 | private enum BASEMODE
746 | {
747 |
748 | BASE_WIDTH, BASE_HEIGHT, BASE_SCREEN_WIDTH, BASE_SCREEN_HEIGHT;
749 |
750 | /**
751 | * width_parent
752 | */
753 | public static final String PERCENT = "%";
754 | /**
755 | * width_parent
756 | */
757 | public static final String W = "w";
758 | /**
759 | * height_parent
760 | */
761 | public static final String H = "h";
762 | /**
763 | * width_screen
764 | */
765 | public static final String SW = "sw";
766 | /**
767 | * height_screen
768 | */
769 | public static final String SH = "sh";
770 | }
771 |
772 | public static class PercentVal
773 | {
774 |
775 | public float percent = -1;
776 | public BASEMODE basemode;
777 |
778 | public PercentVal()
779 | {
780 | }
781 |
782 | public PercentVal(float percent, BASEMODE baseMode)
783 | {
784 | this.percent = percent;
785 | this.basemode = baseMode;
786 | }
787 |
788 | @Override
789 | public String toString()
790 | {
791 | return "PercentVal{" +
792 | "percent=" + percent +
793 | ", basemode=" + basemode.name() +
794 | '}';
795 | }
796 | }
797 |
798 | public PercentVal widthPercent;
799 | public PercentVal heightPercent;
800 |
801 | public PercentVal leftMarginPercent;
802 | public PercentVal topMarginPercent;
803 | public PercentVal rightMarginPercent;
804 | public PercentVal bottomMarginPercent;
805 | public PercentVal startMarginPercent;
806 | public PercentVal endMarginPercent;
807 |
808 | public PercentVal textSizePercent;
809 |
810 | //1.0.4 those attr for some views' setMax/min Height/Width method
811 | public PercentVal maxWidthPercent;
812 | public PercentVal maxHeightPercent;
813 | public PercentVal minWidthPercent;
814 | public PercentVal minHeightPercent;
815 |
816 | //1.0.6 add padding supprot
817 | public PercentVal paddingLeftPercent;
818 | public PercentVal paddingRightPercent;
819 | public PercentVal paddingTopPercent;
820 | public PercentVal paddingBottomPercent;
821 |
822 |
823 | /* package */ final ViewGroup.MarginLayoutParams mPreservedParams;
824 |
825 |
826 | public PercentLayoutInfo()
827 | {
828 | mPreservedParams = new ViewGroup.MarginLayoutParams(0, 0);
829 | }
830 |
831 | /**
832 | * Fills {@code ViewGroup.LayoutParams} dimensions based on percentage values.
833 | */
834 | public void fillLayoutParams(ViewGroup.LayoutParams params, int widthHint,
835 | int heightHint)
836 | {
837 | // Preserve the original layout params, so we can restore them after the measure step.
838 | mPreservedParams.width = params.width;
839 | mPreservedParams.height = params.height;
840 |
841 | if (widthPercent != null)
842 | {
843 | int base = getBaseByModeAndVal(widthHint, heightHint, widthPercent.basemode);
844 | params.width = (int) (base * widthPercent.percent);
845 | }
846 | if (heightPercent != null)
847 | {
848 | int base = getBaseByModeAndVal(widthHint, heightHint, heightPercent.basemode);
849 | params.height = (int) (base * heightPercent.percent);
850 | }
851 |
852 | if (Log.isLoggable(TAG, Log.DEBUG))
853 | {
854 | Log.d(TAG, "after fillLayoutParams: (" + params.width + ", " + params.height + ")");
855 | }
856 | }
857 |
858 | /**
859 | * Fills {@code ViewGroup.MarginLayoutParams} dimensions and margins based on percentage
860 | * values.
861 | */
862 | public void fillMarginLayoutParams(ViewGroup.MarginLayoutParams params, int widthHint,
863 | int heightHint)
864 | {
865 | fillLayoutParams(params, widthHint, heightHint);
866 |
867 | // Preserver the original margins, so we can restore them after the measure step.
868 | mPreservedParams.leftMargin = params.leftMargin;
869 | mPreservedParams.topMargin = params.topMargin;
870 | mPreservedParams.rightMargin = params.rightMargin;
871 | mPreservedParams.bottomMargin = params.bottomMargin;
872 | MarginLayoutParamsCompat.setMarginStart(mPreservedParams,
873 | MarginLayoutParamsCompat.getMarginStart(params));
874 | MarginLayoutParamsCompat.setMarginEnd(mPreservedParams,
875 | MarginLayoutParamsCompat.getMarginEnd(params));
876 |
877 | if (leftMarginPercent != null)
878 | {
879 | int base = getBaseByModeAndVal(widthHint, heightHint, leftMarginPercent.basemode);
880 | params.leftMargin = (int) (base * leftMarginPercent.percent);
881 | }
882 | if (topMarginPercent != null)
883 | {
884 | int base = getBaseByModeAndVal(widthHint, heightHint, topMarginPercent.basemode);
885 | params.topMargin = (int) (base * topMarginPercent.percent);
886 | }
887 | if (rightMarginPercent != null)
888 | {
889 | int base = getBaseByModeAndVal(widthHint, heightHint, rightMarginPercent.basemode);
890 | params.rightMargin = (int) (base * rightMarginPercent.percent);
891 | }
892 | if (bottomMarginPercent != null)
893 | {
894 | int base = getBaseByModeAndVal(widthHint, heightHint, bottomMarginPercent.basemode);
895 | params.bottomMargin = (int) (base * bottomMarginPercent.percent);
896 | }
897 | if (startMarginPercent != null)
898 | {
899 | int base = getBaseByModeAndVal(widthHint, heightHint, startMarginPercent.basemode);
900 | MarginLayoutParamsCompat.setMarginStart(params,
901 | (int) (base * startMarginPercent.percent));
902 | }
903 | if (endMarginPercent != null)
904 | {
905 | int base = getBaseByModeAndVal(widthHint, heightHint, endMarginPercent.basemode);
906 | MarginLayoutParamsCompat.setMarginEnd(params,
907 | (int) (base * endMarginPercent.percent));
908 | }
909 | if (Log.isLoggable(TAG, Log.DEBUG))
910 | {
911 | Log.d(TAG, "after fillMarginLayoutParams: (" + params.width + ", " + params.height
912 | + ")");
913 | }
914 | }
915 |
916 | @Override
917 | public String toString()
918 | {
919 | return "PercentLayoutInfo{" +
920 | "widthPercent=" + widthPercent +
921 | ", heightPercent=" + heightPercent +
922 | ", leftMarginPercent=" + leftMarginPercent +
923 | ", topMarginPercent=" + topMarginPercent +
924 | ", rightMarginPercent=" + rightMarginPercent +
925 | ", bottomMarginPercent=" + bottomMarginPercent +
926 | ", startMarginPercent=" + startMarginPercent +
927 | ", endMarginPercent=" + endMarginPercent +
928 | ", textSizePercent=" + textSizePercent +
929 | ", maxWidthPercent=" + maxWidthPercent +
930 | ", maxHeightPercent=" + maxHeightPercent +
931 | ", minWidthPercent=" + minWidthPercent +
932 | ", minHeightPercent=" + minHeightPercent +
933 | ", paddingLeftPercent=" + paddingLeftPercent +
934 | ", paddingRightPercent=" + paddingRightPercent +
935 | ", paddingTopPercent=" + paddingTopPercent +
936 | ", paddingBottomPercent=" + paddingBottomPercent +
937 | ", mPreservedParams=" + mPreservedParams +
938 | '}';
939 | }
940 |
941 | /**
942 | * Restores original dimensions and margins after they were changed for percentage based
943 | * values. Calling this method only makes sense if you previously called
944 | * {@link PercentLayoutHelper.PercentLayoutInfo#fillMarginLayoutParams}.
945 | */
946 | public void restoreMarginLayoutParams(ViewGroup.MarginLayoutParams params)
947 | {
948 | restoreLayoutParams(params);
949 | params.leftMargin = mPreservedParams.leftMargin;
950 | params.topMargin = mPreservedParams.topMargin;
951 | params.rightMargin = mPreservedParams.rightMargin;
952 | params.bottomMargin = mPreservedParams.bottomMargin;
953 | MarginLayoutParamsCompat.setMarginStart(params,
954 | MarginLayoutParamsCompat.getMarginStart(mPreservedParams));
955 | MarginLayoutParamsCompat.setMarginEnd(params,
956 | MarginLayoutParamsCompat.getMarginEnd(mPreservedParams));
957 | }
958 |
959 | /**
960 | * Restores original dimensions after they were changed for percentage based values. Calling
961 | * this method only makes sense if you previously called
962 | * {@link PercentLayoutHelper.PercentLayoutInfo#fillLayoutParams}.
963 | */
964 | public void restoreLayoutParams(ViewGroup.LayoutParams params)
965 | {
966 | params.width = mPreservedParams.width;
967 | params.height = mPreservedParams.height;
968 | }
969 | }
970 |
971 | /**
972 | * If a layout wants to support percentage based dimensions and use this helper class, its
973 | * {@code LayoutParams} subclass must implement this interface.
974 | *
975 | * Your {@code LayoutParams} subclass should contain an instance of {@code PercentLayoutInfo}
976 | * and the implementation of this interface should be a simple accessor.
977 | */
978 | public interface PercentLayoutParams
979 | {
980 | PercentLayoutInfo getPercentLayoutInfo();
981 | }
982 | }
983 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/java/com/zhy/android/percent/support/PercentLinearLayout.java:
--------------------------------------------------------------------------------
1 | package com.zhy.android.percent.support;
2 |
3 | import android.app.Activity;
4 | import android.content.Context;
5 | import android.content.res.TypedArray;
6 | import android.util.AttributeSet;
7 | import android.util.DisplayMetrics;
8 | import android.view.View;
9 | import android.view.ViewGroup;
10 | import android.view.WindowManager;
11 | import android.widget.LinearLayout;
12 | import android.widget.ScrollView;
13 |
14 | /**
15 | * Created by zhy on 15/6/30.
16 | */
17 | public class PercentLinearLayout extends LinearLayout
18 | {
19 |
20 | private static final String TAG = "PercentLinearLayout";
21 | private PercentLayoutHelper mPercentLayoutHelper;
22 |
23 | public PercentLinearLayout(Context context, AttributeSet attrs)
24 | {
25 | super(context, attrs);
26 |
27 | mPercentLayoutHelper = new PercentLayoutHelper(this);
28 | }
29 |
30 |
31 | @Override
32 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
33 | {
34 |
35 | int heightSize = View.MeasureSpec.getSize(heightMeasureSpec);
36 | int heightMode = View.MeasureSpec.getMode(heightMeasureSpec);
37 | int tmpHeightMeasureSpec = MeasureSpec.makeMeasureSpec(heightSize, heightMode);
38 |
39 | int widthSize = View.MeasureSpec.getSize(widthMeasureSpec);
40 | int widthMode = View.MeasureSpec.getMode(widthMeasureSpec);
41 | int tmpWidthMeasureSpec = MeasureSpec.makeMeasureSpec(widthSize, widthMode);
42 |
43 | //fixed scrollview height problems
44 | if (heightMode == MeasureSpec.UNSPECIFIED && getParent() != null && (getParent() instanceof ScrollView))
45 | {
46 | int baseHeight = 0;
47 | Context context = getContext();
48 | if (context instanceof Activity)
49 | {
50 | Activity act = (Activity) context;
51 | int measuredHeight = act.findViewById(android.R.id.content).getMeasuredHeight();
52 | baseHeight = measuredHeight;
53 | } else
54 | {
55 | baseHeight = getScreenHeight();
56 | }
57 | tmpHeightMeasureSpec = MeasureSpec.makeMeasureSpec(baseHeight, heightMode);
58 | }
59 |
60 |
61 | mPercentLayoutHelper.adjustChildren(tmpWidthMeasureSpec, tmpHeightMeasureSpec);
62 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
63 | if (mPercentLayoutHelper.handleMeasuredStateTooSmall())
64 | {
65 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
66 | }
67 | }
68 |
69 | private int getScreenHeight()
70 | {
71 | WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
72 | DisplayMetrics outMetrics = new DisplayMetrics();
73 | wm.getDefaultDisplay().getMetrics(outMetrics);
74 | return outMetrics.heightPixels;
75 | }
76 |
77 | @Override
78 | protected void onLayout(boolean changed, int l, int t, int r, int b)
79 | {
80 | super.onLayout(changed, l, t, r, b);
81 | mPercentLayoutHelper.restoreOriginalParams();
82 | }
83 |
84 | @Override
85 | public LayoutParams generateLayoutParams(AttributeSet attrs)
86 | {
87 | return new LayoutParams(getContext(), attrs);
88 | }
89 |
90 |
91 | public static class LayoutParams extends LinearLayout.LayoutParams
92 | implements PercentLayoutHelper.PercentLayoutParams
93 | {
94 | private PercentLayoutHelper.PercentLayoutInfo mPercentLayoutInfo;
95 |
96 | public LayoutParams(Context c, AttributeSet attrs)
97 | {
98 | super(c, attrs);
99 | mPercentLayoutInfo = PercentLayoutHelper.getPercentLayoutInfo(c, attrs);
100 | }
101 |
102 | @Override
103 | public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo()
104 | {
105 | return mPercentLayoutInfo;
106 | }
107 |
108 | @Override
109 | protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr)
110 | {
111 | PercentLayoutHelper.fetchWidthAndHeight(this, a, widthAttr, heightAttr);
112 | }
113 |
114 | public LayoutParams(int width, int height)
115 | {
116 | super(width, height);
117 | }
118 |
119 |
120 | public LayoutParams(ViewGroup.LayoutParams source)
121 | {
122 | super(source);
123 | }
124 |
125 | public LayoutParams(MarginLayoutParams source)
126 | {
127 | super(source);
128 | }
129 |
130 | }
131 |
132 | }
133 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/java/com/zhy/android/percent/support/PercentRelativeLayout.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2015 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.zhy.android.percent.support;
18 |
19 | import android.content.Context;
20 | import android.content.res.TypedArray;
21 | import android.util.AttributeSet;
22 | import android.view.ViewGroup;
23 | import android.widget.RelativeLayout;
24 |
25 | /**
26 | * Subclass of {@link RelativeLayout} that supports percentage based dimensions and
27 | * margins.
28 | *
29 | * You can specify dimension or a margin of child by using attributes with "Percent" suffix. Follow
30 | * this example:
31 | *
32 | *
33 | * <android.support.percent.PercentRelativeLayout
34 | * xmlns:android="http://schemas.android.com/apk/res/android"
35 | * xmlns:app="http://schemas.android.com/apk/res-auto"
36 | * android:layout_width="match_parent"
37 | * android:layout_height="match_parent"/>
38 | * <ImageView
39 | * app:layout_widthPercent="50%"
40 | * app:layout_heightPercent="50%"
41 | * app:layout_marginTopPercent="25%"
42 | * app:layout_marginLeftPercent="25%"/>
43 | * </android.support.percent.PercentFrameLayout/>
44 | *
45 | *
46 | * The attributes that you can use are:
47 | *
48 | * - {@code layout_widthPercent}
49 | *
- {@code layout_heightPercent}
50 | *
- {@code layout_marginPercent}
51 | *
- {@code layout_marginLeftPercent}
52 | *
- {@code layout_marginTopPercent}
53 | *
- {@code layout_marginRightPercent}
54 | *
- {@code layout_marginBottomPercent}
55 | *
- {@code layout_marginStartPercent}
56 | *
- {@code layout_marginEndPercent}
57 | *
58 | *
59 | * It is not necessary to specify {@code layout_width/height} if you specify {@code
60 | * layout_widthPercent.} However, if you want the view to be able to take up more space than what
61 | * percentage value permits, you can add {@code layout_width/height="wrap_content"}. In that case
62 | * if the percentage size is too small for the View's content, it will be resized using
63 | * {@code wrap_content} rule.
64 | */
65 | public class PercentRelativeLayout extends RelativeLayout {
66 | private final PercentLayoutHelper mHelper = new PercentLayoutHelper(this);
67 |
68 | public PercentRelativeLayout(Context context) {
69 | super(context);
70 | }
71 |
72 | public PercentRelativeLayout(Context context, AttributeSet attrs) {
73 | super(context, attrs);
74 | }
75 |
76 | public PercentRelativeLayout(Context context, AttributeSet attrs, int defStyle) {
77 | super(context, attrs, defStyle);
78 | }
79 |
80 | @Override
81 | public LayoutParams generateLayoutParams(AttributeSet attrs) {
82 | return new LayoutParams(getContext(), attrs);
83 | }
84 |
85 | @Override
86 | protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
87 | mHelper.adjustChildren(widthMeasureSpec, heightMeasureSpec);
88 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
89 | if (mHelper.handleMeasuredStateTooSmall()) {
90 | super.onMeasure(widthMeasureSpec, heightMeasureSpec);
91 | }
92 | }
93 |
94 | @Override
95 | protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
96 | super.onLayout(changed, left, top, right, bottom);
97 | mHelper.restoreOriginalParams();
98 | }
99 |
100 | public static class LayoutParams extends RelativeLayout.LayoutParams
101 | implements PercentLayoutHelper.PercentLayoutParams {
102 | private PercentLayoutHelper.PercentLayoutInfo mPercentLayoutInfo;
103 |
104 | public LayoutParams(Context c, AttributeSet attrs) {
105 | super(c, attrs);
106 | mPercentLayoutInfo = PercentLayoutHelper.getPercentLayoutInfo(c, attrs);
107 | }
108 |
109 | public LayoutParams(int width, int height) {
110 | super(width, height);
111 | }
112 |
113 | public LayoutParams(ViewGroup.LayoutParams source) {
114 | super(source);
115 | }
116 |
117 | public LayoutParams(MarginLayoutParams source) {
118 | super(source);
119 | }
120 |
121 | @Override
122 | public PercentLayoutHelper.PercentLayoutInfo getPercentLayoutInfo() {
123 | return mPercentLayoutInfo;
124 | }
125 |
126 | @Override
127 | protected void setBaseAttributes(TypedArray a, int widthAttr, int heightAttr) {
128 | PercentLayoutHelper.fetchWidthAndHeight(this, a, widthAttr, heightAttr);
129 | }
130 | }
131 | }
132 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/main1.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/res/values/attrs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/percent-support-extends/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | AndroidPercentSupportExtends
3 |
4 |
--------------------------------------------------------------------------------
/percent_04.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/percent_04.gif
--------------------------------------------------------------------------------
/percent_sw_sh.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/percent_sw_sh.png
--------------------------------------------------------------------------------
/percent_sw_sh_single.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/percent_sw_sh_single.png
--------------------------------------------------------------------------------
/sc_02.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/sc_02.png
--------------------------------------------------------------------------------
/sc_02_full.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/sc_02_full.png
--------------------------------------------------------------------------------
/sc_03.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/sc_03.png
--------------------------------------------------------------------------------
/sc_03_full.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hongyangAndroid/android-percent-support-extend/87a2fed084cf6b6b8adc26134215d11a5fbb36bf/sc_03_full.png
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app', ':percent-support-extends', ':percent-support-extends-sample'
2 |
--------------------------------------------------------------------------------
169 |
170 | xml:
171 |
172 | ```xml
173 |
174 |
175 |
176 | 
234 |
235 | xml:
236 |
237 | ```xml
238 |
239 | 
316 |
317 | xml:
318 |
319 | ```xml
320 |
321 |
322 | 
414 |
415 | 
416 |
417 | ```xml
418 |
419 | 
494 |
495 |
496 |
497 |
498 |
499 |
500 | 
87 |
88 | xml:
89 |
90 | ```xml
91 |
92 |
93 |
94 | 
159 |
160 | xml:
161 |
162 | ```xml
163 |
164 |
165 |
166 | 
220 |
221 | xml:
222 |
223 | ```xml
224 |
225 |