Introduction of GridLayout.
Change-Id: Ia2ec315e7d29dcc5aa13b080fc6ce00708e9c034
diff --git a/api/current.txt b/api/current.txt
index 2f5b9b4..fdef20f 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -301,7 +301,9 @@
field public static final int colorBackgroundCacheHint = 16843435; // 0x10102ab
field public static final int colorForeground = 16842800; // 0x1010030
field public static final int colorForegroundInverse = 16843270; // 0x1010206
+ field public static final int columnCount = 16843633; // 0x1010371
field public static final int columnDelay = 16843215; // 0x10101cf
+ field public static final int columnOrderPreserved = 16843634; // 0x1010372
field public static final int columnWidth = 16843031; // 0x1010117
field public static final int completionHint = 16843122; // 0x1010172
field public static final int completionHintView = 16843123; // 0x1010173
@@ -575,6 +577,8 @@
field public static final int layout_centerInParent = 16843151; // 0x101018f
field public static final int layout_centerVertical = 16843153; // 0x1010191
field public static final int layout_column = 16843084; // 0x101014c
+ field public static final int layout_columnSpan = 16843639; // 0x1010377
+ field public static final int layout_columnWeight = 16843640; // 0x1010378
field public static final int layout_gravity = 16842931; // 0x10100b3
field public static final int layout_height = 16842997; // 0x10100f5
field public static final int layout_margin = 16842998; // 0x10100f6
@@ -582,6 +586,9 @@
field public static final int layout_marginLeft = 16842999; // 0x10100f7
field public static final int layout_marginRight = 16843001; // 0x10100f9
field public static final int layout_marginTop = 16843000; // 0x10100f8
+ field public static final int layout_row = 16843636; // 0x1010374
+ field public static final int layout_rowSpan = 16843637; // 0x1010375
+ field public static final int layout_rowWeight = 16843638; // 0x1010376
field public static final int layout_scale = 16843155; // 0x1010193
field public static final int layout_span = 16843085; // 0x101014d
field public static final int layout_toLeftOf = 16843138; // 0x1010182
@@ -751,9 +758,11 @@
field public static final int rotation = 16843558; // 0x1010326
field public static final int rotationX = 16843559; // 0x1010327
field public static final int rotationY = 16843560; // 0x1010328
+ field public static final int rowCount = 16843631; // 0x101036f
field public static final int rowDelay = 16843216; // 0x10101d0
field public static final int rowEdgeFlags = 16843329; // 0x1010241
field public static final int rowHeight = 16843058; // 0x1010132
+ field public static final int rowOrderPreserved = 16843632; // 0x1010370
field public static final int saveEnabled = 16842983; // 0x10100e7
field public static final int scaleGravity = 16843262; // 0x10101fe
field public static final int scaleHeight = 16843261; // 0x10101fd
@@ -984,6 +993,7 @@
field public static final int unfocusedMonthDateColor = 16843588; // 0x1010344
field public static final int unselectedAlpha = 16843278; // 0x101020e
field public static final int updatePeriodMillis = 16843344; // 0x1010250
+ field public static final int useDefaultMargins = 16843635; // 0x1010373
field public static final int useIntrinsicSizeAsMinimum = 16843536; // 0x1010310
field public static final int useLevel = 16843167; // 0x101019f
field public static final int userVisible = 16843409; // 0x1010291
@@ -24167,6 +24177,67 @@
ctor public Gallery.LayoutParams(android.view.ViewGroup.LayoutParams);
}
+ public class GridLayout extends android.view.ViewGroup {
+ ctor public GridLayout(android.content.Context);
+ ctor public GridLayout(android.content.Context, android.util.AttributeSet, int);
+ ctor public GridLayout(android.content.Context, android.util.AttributeSet);
+ method public int getColumnCount();
+ method public int getOrientation();
+ method public int getRowCount();
+ method public boolean getUseDefaultMargins();
+ method public boolean isColumnOrderPreserved();
+ method public boolean isRowOrderPreserved();
+ method protected void onLayout(boolean, int, int, int, int);
+ method public void setColumnCount(int);
+ method public void setColumnOrderPreserved(boolean);
+ method public void setOrientation(int);
+ method public void setRowCount(int);
+ method public void setRowOrderPreserved(boolean);
+ method public void setUseDefaultMargins(boolean);
+ field public static final android.widget.GridLayout.Alignment BASELINE;
+ field public static final android.widget.GridLayout.Alignment BOTTOM;
+ field public static final android.widget.GridLayout.Alignment CENTER;
+ field public static final android.widget.GridLayout.Alignment FILL;
+ field public static final int HORIZONTAL = 0; // 0x0
+ field public static final android.widget.GridLayout.Alignment LEFT;
+ field public static final android.widget.GridLayout.Alignment RIGHT;
+ field public static final android.widget.GridLayout.Alignment TOP;
+ field public static final int VERTICAL = 1; // 0x1
+ }
+
+ public static abstract interface GridLayout.Alignment {
+ method public abstract int getAlignmentValue(android.view.View, int);
+ method public abstract int getSizeInCell(android.view.View, int, int);
+ }
+
+ public static class GridLayout.Group {
+ ctor public GridLayout.Group(android.widget.GridLayout.Interval, android.widget.GridLayout.Alignment);
+ ctor public GridLayout.Group(int, int, android.widget.GridLayout.Alignment);
+ ctor public GridLayout.Group(int, android.widget.GridLayout.Alignment);
+ field public final android.widget.GridLayout.Alignment alignment;
+ field public final android.widget.GridLayout.Interval span;
+ }
+
+ public static class GridLayout.Interval {
+ ctor public GridLayout.Interval(int, int);
+ field public final int max;
+ field public final int min;
+ }
+
+ public static class GridLayout.LayoutParams extends android.view.ViewGroup.MarginLayoutParams {
+ ctor public GridLayout.LayoutParams(android.widget.GridLayout.Group, android.widget.GridLayout.Group);
+ ctor public GridLayout.LayoutParams();
+ ctor public GridLayout.LayoutParams(android.view.ViewGroup.LayoutParams);
+ ctor public GridLayout.LayoutParams(android.view.ViewGroup.MarginLayoutParams);
+ ctor public GridLayout.LayoutParams(android.widget.GridLayout.LayoutParams);
+ ctor public GridLayout.LayoutParams(android.content.Context, android.util.AttributeSet);
+ method public void setGravity(int);
+ field public android.widget.GridLayout.Group columnGroup;
+ field public float columnWeight;
+ field public android.widget.GridLayout.Group rowGroup;
+ field public float rowWeight;
+ }
+
public class GridView extends android.widget.AbsListView {
ctor public GridView(android.content.Context);
ctor public GridView(android.content.Context, android.util.AttributeSet);
@@ -25049,6 +25120,12 @@
method public abstract void onScrollStarted();
}
+ public final class Space extends android.view.View {
+ ctor public Space(android.content.Context, android.util.AttributeSet, int);
+ ctor public Space(android.content.Context, android.util.AttributeSet);
+ ctor public Space(android.content.Context);
+ }
+
public class Spinner extends android.widget.AbsSpinner implements android.content.DialogInterface.OnClickListener {
ctor public Spinner(android.content.Context);
ctor public Spinner(android.content.Context, int);
diff --git a/core/java/android/widget/GridLayout.java b/core/java/android/widget/GridLayout.java
new file mode 100644
index 0000000..4889101
--- /dev/null
+++ b/core/java/android/widget/GridLayout.java
@@ -0,0 +1,2036 @@
+/*
+ * Copyright (C) 2011 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.widget;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Rect;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import com.android.internal.R.styleable;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static java.lang.Math.max;
+import static java.lang.Math.min;
+
+/**
+ * A layout that places its children in a rectangular <em>grid</em>.
+ * <p>
+ * The grid is composed of a set of infinitely thin lines that separate the
+ * viewing area into <em>cells</em>. Throughout the API, grid lines are referenced
+ * by grid <em>indices</em>. A grid that has <code>N</code> columns
+ * has <code>N + 1</code> grid indices that run from <code>0</code>
+ * through <code>N</code> inclusive. Regardless of how GridLayout is
+ * configured, grid index <code>0</code> is fixed to the leading edge of the
+ * container and grid index <code>N</code> is fixed to its trailing edge
+ * (after padding is taken into account).
+ *
+ * <h4>Row and Column Groups</h4>
+ *
+ * Children occupy one or more contiguous cells, as defined
+ * by their {@link GridLayout.LayoutParams#rowGroup rowGroup} and
+ * {@link GridLayout.LayoutParams#columnGroup columnGroup} layout parameters.
+ * Each group specifies the set of rows or columns that are to be
+ * occupied; and how children should be aligned within the resulting group of cells.
+ * Although cells do not normally overlap in a GridLayout, GridLayout does
+ * not prevent children being defined to occupy the same cell or group of cells.
+ * In this case however, there is no guarantee that children will not themselves
+ * overlap after the layout operation completes.
+ *
+ * <h4>Default Cell Assignment</h4>
+ *
+ * If no child specifies the row and column indices of the cell it
+ * wishes to occupy, GridLayout assigns cell locations automatically using its:
+ * {@link GridLayout#setOrientation(int) orientation},
+ * {@link GridLayout#setRowCount(int) rowCount} and
+ * {@link GridLayout#setColumnCount(int) columnCount} properties.
+ *
+ * <h4>Space</h4>
+ *
+ * Space between children may be specified either by using instances of the
+ * dedicated {@link Space} view or by setting the
+ *
+ * {@link ViewGroup.MarginLayoutParams#leftMargin leftMargin},
+ * {@link ViewGroup.MarginLayoutParams#topMargin topMargin},
+ * {@link ViewGroup.MarginLayoutParams#rightMargin rightMargin} and
+ * {@link ViewGroup.MarginLayoutParams#bottomMargin bottomMargin}
+ *
+ * layout parameters. When the
+ * {@link GridLayout#setUseDefaultMargins(boolean) useDefaultMargins}
+ * property is set, default margins around children are automatically
+ * allocated based on the child's visual characteristics. Each of the
+ * margins so defined may be independently overridden by an assignment
+ * to the appropriate layout parameter.
+ *
+ * <h4>Excess Space Distribution</h4>
+ *
+ * Like {@link LinearLayout}, a child's ability to stretch is controlled
+ * using <em>weights</em>, which are specified using the
+ * {@link GridLayout.LayoutParams#rowWeight rowWeight} and
+ * {@link GridLayout.LayoutParams#columnWeight columnWeight} layout parameters.
+ * <p>
+ * <p>
+ * See {@link GridLayout.LayoutParams} for a full description of the
+ * layout parameters used by GridLayout.
+ *
+ * @attr ref android.R.styleable#GridLayout_orientation
+ * @attr ref android.R.styleable#GridLayout_rowCount
+ * @attr ref android.R.styleable#GridLayout_columnCount
+ * @attr ref android.R.styleable#GridLayout_useDefaultMargins
+ * @attr ref android.R.styleable#GridLayout_rowOrderPreserved
+ * @attr ref android.R.styleable#GridLayout_columnOrderPreserved
+ */
+public class GridLayout extends ViewGroup {
+
+ // Public constants
+
+ /**
+ * The horizontal orientation.
+ */
+ public static final int HORIZONTAL = LinearLayout.HORIZONTAL;
+ /**
+ * The vertical orientation.
+ */
+ public static final int VERTICAL = LinearLayout.VERTICAL;
+
+ // Misc constants
+
+ private static final String TAG = GridLayout.class.getName();
+ private static final boolean DEBUG = false;
+ private static final int UNDEFINED = Integer.MIN_VALUE;
+ private static final Paint GRID_PAINT = new Paint();
+ private static final double GOLDEN_RATIO = (1 + Math.sqrt(5)) / 2;
+ private static final int MIN = 0;
+ private static final int PRF = 1;
+ private static final int MAX = 2;
+
+ // Defaults
+
+ private static final int DEFAULT_ORIENTATION = HORIZONTAL;
+ private static final int DEFAULT_COUNT = UNDEFINED;
+ private static final boolean DEFAULT_USE_DEFAULT_MARGINS = false;
+ private static final boolean DEFAULT_ORDER_PRESERVED = false;
+
+ // TypedArray indices
+
+ private static final int ORIENTATION = styleable.GridLayout_orientation;
+ private static final int ROW_COUNT = styleable.GridLayout_rowCount;
+ private static final int COLUMN_COUNT = styleable.GridLayout_columnCount;
+ private static final int USE_DEFAULT_MARGINS = styleable.GridLayout_useDefaultMargins;
+ private static final int ROW_ORDER_PRESERVED = styleable.GridLayout_rowOrderPreserved;
+ private static final int COLUMN_ORDER_PRESERVED = styleable.GridLayout_columnOrderPreserved;
+
+ // Instance variables
+
+ private final Axis mHorizontalAxis = new Axis(true);
+ private final Axis mVerticalAxis = new Axis(false);
+ private boolean mLayoutParamsValid = false;
+ private int mOrientation = DEFAULT_ORIENTATION;
+ private boolean mUseDefaultMargins = DEFAULT_USE_DEFAULT_MARGINS;
+ private int mDefaultGravity = Gravity.NO_GRAVITY;
+ boolean maximizing = false;
+ boolean accommodateBothMinAndMax = false;
+
+ // Constructors
+
+ /**
+ * {@inheritDoc}
+ */
+ public GridLayout(Context context) {
+ super(context);
+ if (DEBUG) {
+ setWillNotDraw(false);
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public GridLayout(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ processAttributes(context, attrs);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public GridLayout(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ processAttributes(context, attrs);
+ }
+
+ private void processAttributes(Context context, AttributeSet attrs) {
+ TypedArray a = context.obtainStyledAttributes(attrs, styleable.GridLayout);
+ try {
+ setRowCount(a.getInteger(ROW_COUNT, DEFAULT_COUNT));
+ setColumnCount(a.getInteger(COLUMN_COUNT, DEFAULT_COUNT));
+ mOrientation = a.getInteger(ORIENTATION, DEFAULT_ORIENTATION);
+ mUseDefaultMargins = a.getBoolean(USE_DEFAULT_MARGINS, DEFAULT_USE_DEFAULT_MARGINS);
+ setRowOrderPreserved(a.getBoolean(ROW_ORDER_PRESERVED, DEFAULT_ORDER_PRESERVED));
+ setColumnOrderPreserved(a.getBoolean(COLUMN_ORDER_PRESERVED, DEFAULT_ORDER_PRESERVED));
+ } finally {
+ a.recycle();
+ }
+ }
+
+ // Implementation
+
+ /**
+ * Returns the current orientation.
+ *
+ * @return either {@link #HORIZONTAL} or {@link #VERTICAL}. The default
+ * is {@link #HORIZONTAL}.
+ *
+ * @see #setOrientation(int)
+ *
+ * @attr ref android.R.styleable#GridLayout_orientation
+ */
+ public int getOrientation() {
+ return mOrientation;
+ }
+
+ /**
+ * The orientation property does not affect layout. Orientation is used
+ * only to generate default row/column indices when they are not specified
+ * by a component's layout parameters.
+ *
+ * @param orientation the orientation, either {@link #HORIZONTAL} or {@link #VERTICAL}.
+ *
+ * @see #getOrientation()
+ *
+ * @attr ref android.R.styleable#GridLayout_orientation
+ */
+ public void setOrientation(int orientation) {
+ if (mOrientation != orientation) {
+ mOrientation = orientation;
+ requestLayout();
+ }
+ }
+
+ /**
+ * Returns the current number of rows. This is either the last value that was set
+ * with {@link #setRowCount(int)} or, if no such value was set, the maximum
+ * value of each the upper bounds defined in {@link LayoutParams#rowGroup}.
+ *
+ * @return the current number of rows
+ *
+ * @see #setRowCount(int)
+ * @see LayoutParams#rowGroup
+ *
+ * @attr ref android.R.styleable#GridLayout_rowCount
+ */
+ public int getRowCount() {
+ return mVerticalAxis.getCount();
+ }
+
+ /**
+ * The rowCount property does not affect layout. RowCount is used
+ * only to generate default row/column indices when they are not specified
+ * by a component's layout parameters.
+ *
+ * @param rowCount the number of rows.
+ *
+ * @see #getRowCount()
+ * @see LayoutParams#rowGroup
+ *
+ * @attr ref android.R.styleable#GridLayout_rowCount
+ */
+ public void setRowCount(int rowCount) {
+ mVerticalAxis.setCount(rowCount);
+ }
+
+ /**
+ * Returns the current number of columns. This is either the last value that was set
+ * with {@link #setColumnCount(int)} or, if no such value was set, the maximum
+ * value of each the upper bounds defined in {@link LayoutParams#columnGroup}.
+ *
+ * @return the current number of columns
+ *
+ * @see #setColumnCount(int)
+ * @see LayoutParams#columnGroup
+ *
+ * @attr ref android.R.styleable#GridLayout_columnCount
+ */
+ public int getColumnCount() {
+ return mHorizontalAxis.getCount();
+ }
+
+ /**
+ * The columnCount property does not affect layout. ColumnCount is used
+ * only to generate default column/column indices when they are not specified
+ * by a component's layout parameters.
+ *
+ * @param columnCount the number of columns.
+ *
+ * @see #getColumnCount()
+ * @see LayoutParams#columnGroup
+ *
+ * @attr ref android.R.styleable#GridLayout_columnCount
+ */
+ public void setColumnCount(int columnCount) {
+ mHorizontalAxis.setCount(columnCount);
+ }
+
+ /**
+ * Returns whether or not this GridLayout will allocate default margins when no
+ * corresponding layout parameters are defined.
+ *
+ * @return true if default margins should be allocated.
+ *
+ * @see #setUseDefaultMargins(boolean)
+ *
+ * @attr ref android.R.styleable#GridLayout_useDefaultMargins
+ */
+ public boolean getUseDefaultMargins() {
+ return mUseDefaultMargins;
+ }
+
+ /**
+ * When true, GridLayout allocates default margins around children
+ * based on the child's visual characteristics. Each of the
+ * margins so defined may be independently overridden by an assignment
+ * to the appropriate layout parameter.
+ * <p>
+ * When false, the default value of all margins is zero.
+ *
+ * @param useDefaultMargins use true to make GridLayout allocate default margins
+ *
+ * @see #getUseDefaultMargins()
+ *
+ * @see MarginLayoutParams#leftMargin
+ * @see MarginLayoutParams#topMargin
+ * @see MarginLayoutParams#rightMargin
+ * @see MarginLayoutParams#bottomMargin
+ *
+ * @attr ref android.R.styleable#GridLayout_useDefaultMargins
+ */
+ public void setUseDefaultMargins(boolean useDefaultMargins) {
+ mUseDefaultMargins = useDefaultMargins;
+ }
+
+ /**
+ * Returns whether or not row boundaries are ordered by their grid indices.
+ *
+ * @return true if row boundaries must appear in the order of their indices, false otherwise.
+ * The default is false.
+ *
+ * @see #setRowOrderPreserved(boolean)
+ *
+ * @attr ref android.R.styleable#GridLayout_rowOrderPreserved
+ */
+ public boolean isRowOrderPreserved() {
+ return mVerticalAxis.isOrderPreserved();
+ }
+
+ /**
+ * When this property is <code>false</code>, the default state, GridLayout
+ * is at liberty to choose an order that better suits the heights of its children.
+ <p>
+ * When this property is <code>true</code>, GridLayout is forced to place row boundaries
+ * (the {@link Interval#min min} and {@link Interval#max max} values of
+ * a {@link LayoutParams#rowGroup rowGroup}'s {@link Group#span span})
+ * so that they appear in ascending order in the view.
+ * <p>
+ * GridLayout implements this specification by creating ordering constraints between
+ * the variables that represent the locations of the row boundaries.
+ *
+ * When this property is <code>true</code>, constraints are added for each pair of consecutive
+ * indices: i.e. between row boundaries: <code>[0..1], [1..2], [3..4],...</code> etc.
+ *
+ * When the property is <code>false</code>, the ordering constraints are placed
+ * only between boundaries that separate opposing edges of the layout's children.
+ *
+ * @param rowOrderPreserved use true to force GridLayout to respect the order
+ * of row boundaries.
+ *
+ * @see #isRowOrderPreserved()
+ *
+ * @attr ref android.R.styleable#GridLayout_rowOrderPreserved
+ */
+ public void setRowOrderPreserved(boolean rowOrderPreserved) {
+ mVerticalAxis.setOrderPreserved(rowOrderPreserved);
+ }
+
+ /**
+ * Returns whether or not column boundaries are ordered by their grid indices.
+ *
+ * @return true if column boundaries must appear in the order of their indices, false otherwise.
+ * The default is false.
+ *
+ * @see #setColumnOrderPreserved(boolean)
+ *
+ * @attr ref android.R.styleable#GridLayout_columnOrderPreserved
+ */
+ public boolean isColumnOrderPreserved() {
+ return mHorizontalAxis.isOrderPreserved();
+ }
+
+ /**
+ * When this property is <code>false</code>, the default state, GridLayout
+ * is at liberty to choose an order that better suits the widths of its children.
+ <p>
+ * When this property is <code>true</code>, GridLayout is forced to place column boundaries
+ * (the {@link Interval#min min} and {@link Interval#max max} values of
+ * a {@link LayoutParams#columnGroup columnGroup}'s {@link Group#span span})
+ * so that they appear in ascending order in the view.
+ * <p>
+ * GridLayout implements this specification by creating ordering constraints between
+ * the variables that represent the locations of the column boundaries.
+ *
+ * When this property is <code>true</code>, constraints are added for each pair of consecutive
+ * indices: i.e. between column boundaries: <code>[0..1], [1..2], [3..4],...</code> etc.
+ *
+ * When the property is <code>false</code>, the ordering constraints are placed
+ * only between boundaries that separate opposing edges of the layout's children.
+ *
+ * @param columnOrderPreserved use true to force GridLayout to respect the order
+ * of column boundaries.
+ *
+ * @see #isColumnOrderPreserved()
+ *
+ * @attr ref android.R.styleable#GridLayout_columnOrderPreserved
+ */
+ public void setColumnOrderPreserved(boolean columnOrderPreserved) {
+ mHorizontalAxis.setOrderPreserved(columnOrderPreserved);
+ }
+
+ private static int compare(int i, int j) {
+ return i < j ? -1 : i > j ? 1 : 0;
+ }
+
+ private static int sum(int[] a) {
+ int result = 0;
+ for (int i = 0, length = a.length; i < length; i++) {
+ result += a[i];
+ }
+ return result;
+ }
+
+ private int getDefaultMargin(View c, boolean leading, boolean horizontal) {
+ // In the absence of any other information, calculate a default gap such
+ // that, in a grid of identical components, the heights and the vertical
+ // gaps are in the proportion of the golden ratio.
+ // To effect this with equal margins at each edge, set each of the
+ // four margin values to half this amount.
+ c.measure(0, 0);
+ return (int) (c.getMeasuredHeight() / GOLDEN_RATIO / 2);
+ }
+
+ private int getDefaultMargin(View c, boolean isAtEdge, boolean leading, boolean horizontal) {
+ // todo remove 20 - use padding here?
+ return isAtEdge ? 20 : getDefaultMargin(c, leading, horizontal);
+ }
+
+ private int getDefaultMarginValue(View c, LayoutParams p, boolean leading, boolean horizontal) {
+ if (!mUseDefaultMargins) {
+ return 0;
+ }
+ Group group = horizontal ? p.columnGroup : p.rowGroup;
+ Axis axis = horizontal ? mHorizontalAxis : mVerticalAxis;
+ Interval span = group.span;
+ boolean isAtEdge = leading ? span.min == 0 : span.max == axis.getCount();
+
+ return getDefaultMargin(c, isAtEdge, leading, horizontal);
+ }
+
+ private int getMargin(View view, boolean leading, boolean horizontal) {
+ LayoutParams lp = getLayoutParams(view);
+ int margin = horizontal ?
+ leading ? lp.leftMargin : lp.rightMargin :
+ leading ? lp.topMargin : lp.bottomMargin;
+ return margin == UNDEFINED ? getDefaultMarginValue(view, lp, leading, horizontal) : margin;
+ }
+
+ private static boolean isUndefined(Interval span) {
+ return span.min == UNDEFINED || span.max == UNDEFINED;
+ }
+
+ private void validateLayoutParams() {
+ // install default indices for cells if *none* are defined
+ if (mHorizontalAxis.maxIndex1() == UNDEFINED || mVerticalAxis.maxIndex1() == UNDEFINED) {
+ boolean horizontal = mOrientation == HORIZONTAL;
+ int count = horizontal ? mHorizontalAxis.count : mVerticalAxis.count;
+ if (count == UNDEFINED) {
+ count = Integer.MAX_VALUE;
+ }
+ int x = 0;
+ int y = 0;
+ int maxSize = 0;
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ LayoutParams lp = getLayoutParams1(getChildAt(i));
+
+ Interval hSpan = lp.columnGroup.span;
+ int cellWidth = hSpan.size();
+
+ Interval vSpan = lp.rowGroup.span;
+ int cellHeight = vSpan.size();
+
+ if (horizontal) {
+ if (x + cellWidth > count) {
+ x = 0;
+ y += maxSize;
+ maxSize = 0;
+ }
+ } else {
+ if (y + cellHeight > count) {
+ y = 0;
+ x += maxSize;
+ maxSize = 0;
+ }
+ }
+ lp.setHorizontalGroupSpan(new Interval(x, x + cellWidth));
+ lp.setVerticalGroupSpan(new Interval(y, y + cellHeight));
+
+ if (horizontal) {
+ x = x + cellWidth;
+ } else {
+ y = y + cellHeight;
+ }
+ maxSize = max(maxSize, horizontal ? cellHeight : cellWidth);
+ }
+ } else {
+ /*
+ At least one row and one column index have been defined.
+ Assume missing row/cols are in error and set them to zero so that
+ they will display top/left and the developer can add the right indices.
+ Without this UNDEFINED would cause ArrayIndexOutOfBoundsException.
+ */
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ LayoutParams lp = getLayoutParams1(getChildAt(i));
+ if (isUndefined(lp.columnGroup.span)) {
+ lp.setHorizontalGroupSpan(LayoutParams.DEFAULT_SPAN);
+ }
+ if (isUndefined(lp.rowGroup.span)) {
+ lp.setVerticalGroupSpan(LayoutParams.DEFAULT_SPAN);
+ }
+ }
+ }
+ }
+
+ private void invalidateStructure() {
+ mLayoutParamsValid = false;
+ mHorizontalAxis.invalidateStructure();
+ mVerticalAxis.invalidateStructure();
+
+ // This can end up being done twice. But better that than not at all.
+ invalidateValues();
+ }
+
+ private void invalidateValues() {
+ mHorizontalAxis.invalidateValues();
+ mVerticalAxis.invalidateValues();
+ }
+
+ private LayoutParams getLayoutParams1(View c) {
+ return (LayoutParams) c.getLayoutParams();
+ }
+
+ private LayoutParams getLayoutParams(View c) {
+ if (!mLayoutParamsValid) {
+ validateLayoutParams();
+ mLayoutParamsValid = true;
+ }
+ return getLayoutParams1(c);
+ }
+
+ @Override
+ protected LayoutParams generateDefaultLayoutParams() {
+ return new LayoutParams();
+ }
+
+ @Override
+ public LayoutParams generateLayoutParams(AttributeSet attrs) {
+ return new LayoutParams(getContext(), attrs, mDefaultGravity);
+ }
+
+ @Override
+ protected LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
+ return new LayoutParams(p);
+ }
+
+ // Draw grid
+
+ private void drawLine(Canvas graphics, int x1, int y1, int x2, int y2, Paint paint) {
+ int dx = getPaddingLeft();
+ int dy = getPaddingTop();
+ graphics.drawLine(dx + x1, dy + y1, dx + x2, dy + y2, paint);
+ }
+
+ @Override
+ protected void onDraw(Canvas canvas) {
+ super.onDraw(canvas);
+
+ if (DEBUG) {
+ int height = getHeight() - getPaddingTop() - getPaddingBottom();
+ int width = getWidth() - getPaddingLeft() - getPaddingRight();
+
+ int[] xs = mHorizontalAxis.locations;
+ for (int i = 0, length = xs.length; i < length; i++) {
+ int x = xs[i];
+ drawLine(canvas, x, 0, x, height - 1, GRID_PAINT);
+ }
+ int[] ys = mVerticalAxis.locations;
+ for (int i = 0, length = ys.length; i < length; i++) {
+ int y = ys[i];
+ drawLine(canvas, 0, y, width - 1, y, GRID_PAINT);
+ }
+ }
+ }
+
+ static {
+ GRID_PAINT.setColor(Color.argb(50, 255, 255, 255));
+ }
+
+ // Add/remove
+
+ @Override
+ public void addView(View child, int index, ViewGroup.LayoutParams params) {
+ super.addView(child, index, params);
+ invalidateStructure();
+ }
+
+ @Override
+ public void removeView(View view) {
+ super.removeView(view);
+ invalidateStructure();
+ }
+
+ @Override
+ public void removeViewInLayout(View view) {
+ super.removeViewInLayout(view);
+ invalidateStructure();
+ }
+
+ @Override
+ public void removeViewsInLayout(int start, int count) {
+ super.removeViewsInLayout(start, count);
+ invalidateStructure();
+ }
+
+ @Override
+ public void removeViewAt(int index) {
+ super.removeViewAt(index);
+ invalidateStructure();
+ }
+
+ // Measurement
+
+ @Override
+ protected void onMeasure(int widthSpec, int heightSpec) {
+ invalidateValues();
+ // int width = MeasureSpec.getSize(widthSpec);
+ // int widthMode = MeasureSpec.getMode(widthSpec);
+ // int height = MeasureSpec.getSize(heightSpec);
+ // int heightMode = MeasureSpec.getMode(heightSpec);
+
+ // todo - handle widthSpec and heightSpec properly
+
+ int computedWidth = getPaddingLeft() + mHorizontalAxis.getPref() + getPaddingRight();
+ int computedHeight = getPaddingTop() + mVerticalAxis.getPref() + getPaddingBottom();
+
+ setMeasuredDimension(
+ resolveSizeAndState(computedWidth, widthSpec, 0),
+ resolveSizeAndState(computedHeight, heightSpec, 0));
+ }
+
+ private int protect(int alignment) {
+ return alignment == UNDEFINED ? 0 : alignment;
+ }
+
+ private int getLocationIncludingMargin(Axis state, int index, boolean leading) {
+ int margin = leading ? state.leadingMargins[index] : -state.trailingMargins[index];
+ return state.locations[index] + margin;
+ }
+
+ private int getMeasurement(View c, boolean horizontal, int measurementType) {
+ LayoutParams lp = (LayoutParams) c.getLayoutParams();
+ // First check to see if the user has specified the size.
+ // If so, return the specified size.
+ int size = horizontal ? lp.width : lp.height;
+ if (size >= 0) {
+ return size;
+ }
+
+ // measureChild(c, 0, 0);
+ c.measure(0, 0);// todo work out correct order of events for measurement calls
+ int result = horizontal ? c.getMeasuredWidth() : c.getMeasuredHeight();
+
+ float weight = horizontal ? lp.columnWeight : lp.rowWeight;
+ Axis axis = horizontal ? mHorizontalAxis : mVerticalAxis;
+ if (weight != 0) {
+ return result + axis.prefSizeOfWeightedComponent;
+ }
+ return result;
+ }
+
+ // Layout container
+
+ @Override
+ protected void onLayout(boolean changed, int l, int t, int r, int b) {
+ invalidateValues();
+
+ int targetWidth = r - l;
+ int targetHeight = b - t;
+
+ int paddingLeft = getPaddingLeft();
+ int paddingTop = getPaddingTop();
+ int paddingRight = getPaddingRight();
+ int paddingBottom = getPaddingBottom();
+
+ mHorizontalAxis.layout(targetWidth - paddingLeft - paddingRight);
+ mVerticalAxis.layout(targetHeight - paddingTop - paddingBottom);
+
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ View view = getChildAt(i);
+ LayoutParams constraints = getLayoutParams(view);
+ Interval hRange = constraints.columnGroup.span;
+ Interval vRange = constraints.rowGroup.span;
+
+ int x1 = getLocationIncludingMargin(mHorizontalAxis, hRange.min, true);
+ int y1 = getLocationIncludingMargin(mVerticalAxis, vRange.min, true);
+
+ int x2 = getLocationIncludingMargin(mHorizontalAxis, hRange.max, false);
+ int y2 = getLocationIncludingMargin(mVerticalAxis, vRange.max, false);
+
+ int cellWidth = x2 - x1;
+ int cellHeight = y2 - y1;
+
+ Bounds minMaxX = mHorizontalAxis.getGroupBounds().getValue(i);
+ Bounds minMaxY = mVerticalAxis.getGroupBounds().getValue(i);
+
+ int pWidth = getMeasurement(view, true, PRF);
+ int pHeight = getMeasurement(view, false, PRF);
+
+ Alignment hAlignment = constraints.columnGroup.alignment;
+ Alignment vAlignment = constraints.rowGroup.alignment;
+
+ int ddx = protect(hAlignment.getAlignmentValue(null, cellWidth - minMaxX.size()));
+ int ddy = protect(vAlignment.getAlignmentValue(null, cellHeight - minMaxY.size()));
+
+ int dx = ddx + -minMaxX.below - hAlignment.getAlignmentValue(view, pWidth);
+ int dy = ddy + -minMaxY.below - vAlignment.getAlignmentValue(view, pHeight);
+
+ int width = hAlignment.getSizeInCell(view, pWidth, cellWidth);
+ int height = vAlignment.getSizeInCell(view, pHeight, cellHeight);
+
+ int cx = paddingLeft + x1 + dx;
+ int cy = paddingTop + y1 + dy;
+ view.layout(cx, cy, cx + width, cy + height);
+ }
+ }
+
+ // Inner classes
+
+ private class Axis {
+ private static final int MIN_VALUE = -1000000;
+ private static final int MAX_VALUE = 1000000;
+
+ private static final int UNVISITED = 0;
+ private static final int PENDING = 1;
+ private static final int COMPLETE = 2;
+
+ public final boolean horizontal;
+
+ public int count = UNDEFINED;
+ public boolean countValid = false;
+ public boolean countWasExplicitySet = false;
+
+ PackedMap<Group, Bounds> groupBounds;
+ public boolean groupBoundsValid = false;
+
+ PackedMap<Interval, Int> spanSizes;
+ public boolean spanSizesValid = false;
+
+ public int[] locations;
+
+ public int[] leadingMargins;
+ public int[] trailingMargins;
+
+ public Arc[] arcs;
+ public boolean arcsValid = false;
+
+ private boolean mOrderPreserved = DEFAULT_ORDER_PRESERVED;
+
+ public int prefSizeOfWeightedComponent;
+
+ private Axis(boolean horizontal) {
+ this.horizontal = horizontal;
+ }
+
+ private int maxIndex(boolean internal) {
+ // note the number Integer.MIN_VALUE + 1 comes up in undefined cells
+ int count = -1;
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ LayoutParams params = internal ?
+ getLayoutParams1(getChildAt(i)) :
+ getLayoutParams(getChildAt(i));
+ Group g = horizontal ? params.columnGroup : params.rowGroup;
+ count = max(count, g.span.min);
+ count = max(count, g.span.max);
+ }
+ return count == -1 ? UNDEFINED : count;
+ }
+
+ private int maxIndex1() {
+ return maxIndex(true);
+ }
+
+ public int getCount() {
+ if (!countWasExplicitySet && !countValid) {
+ count = max(0, maxIndex(false)); // if there are no cells, the count is zero
+ countValid = true;
+ }
+ return count;
+ }
+
+ public void setCount(int count) {
+ this.count = count;
+ this.countWasExplicitySet = count != UNDEFINED;
+ }
+
+ public boolean isOrderPreserved() {
+ return mOrderPreserved;
+ }
+
+ public void setOrderPreserved(boolean orderPreserved) {
+ mOrderPreserved = orderPreserved;
+ invalidateStructure();
+ }
+
+ private PackedMap<Group, Bounds> createGroupBounds() {
+ int N = getChildCount();
+ Group[] groups = new Group[N];
+ Bounds[] bounds = new Bounds[N];
+ for (int i = 0; i < N; i++) {
+ LayoutParams lp = getLayoutParams(getChildAt(i));
+ Group group = horizontal ? lp.columnGroup : lp.rowGroup;
+
+ groups[i] = group;
+ bounds[i] = new Bounds();
+ }
+
+ return new PackedMap<Group, Bounds>(groups, bounds);
+ }
+
+ private void computeGroupBounds() {
+ for (int i = 0; i < groupBounds.values.length; i++) {
+ groupBounds.values[i].reset();
+ }
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ View c = getChildAt(i);
+ LayoutParams lp = getLayoutParams(c);
+ Group g = horizontal ? lp.columnGroup : lp.rowGroup;
+
+ Bounds bounds = groupBounds.getValue(i);
+ int dim = getMeasurement(c, horizontal, PRF);
+ // todo test this works correctly when the returned value is UNDEFINED
+ int below = g.alignment.getAlignmentValue(c, dim);
+ int above = dim - below;
+ bounds.include(-below, above);
+ }
+ }
+
+ private PackedMap<Group, Bounds> getGroupBounds() {
+ if (groupBounds == null) {
+ groupBounds = createGroupBounds();
+ }
+ if (!groupBoundsValid) {
+ computeGroupBounds();
+ groupBoundsValid = true;
+ }
+ return groupBounds;
+ }
+
+ // Add values computed by alignment - taking the max of all alignments in each span
+ private PackedMap<Interval, Int> createSpanSizes() {
+ PackedMap<Group, Bounds> groupBounds = getGroupBounds();
+ int N = groupBounds.keys.length;
+ Interval[] spans = new Interval[N];
+ Int[] values = new Int[N];
+ for (int i = 0; i < N; i++) {
+ Interval key = groupBounds.keys[i].span;
+
+ spans[i] = key;
+ values[i] = new Int();
+ }
+ return new PackedMap<Interval, Int>(spans, values);
+ }
+
+ private void computeSpanSizes() {
+ Int[] spans = spanSizes.values;
+ for (int i = 0; i < spans.length; i++) {
+ spans[i].reset();
+ }
+
+ Bounds[] bounds = getGroupBounds().values; // us get to trigger a re-evaluation
+ for (int i = 0; i < bounds.length; i++) {
+ int value = bounds[i].size();
+
+ Int valueHolder = spanSizes.getValue(i);
+ valueHolder.value = max(valueHolder.value, value);
+ }
+ }
+
+ private PackedMap<Interval, Int> getSpanSizes() {
+ if (spanSizes == null) {
+ spanSizes = createSpanSizes();
+ }
+ if (!spanSizesValid) {
+ computeSpanSizes();
+ spanSizesValid = true;
+ }
+ return spanSizes;
+ }
+
+ private void include(List<Arc> arcs, Interval key, Int size, boolean maximizing) {
+ key = maximizing ? key.inverse() : key;
+ size = maximizing ? size.neg() : size;
+ // this bit below should really be computed outside here -
+ // its just to stop default (col>0) constraints obliterating valid entries
+ for (Arc arc : arcs) {
+ Interval span = arc.span;
+ if (span.equals(key)) {
+ return;
+ }
+ }
+ arcs.add(new Arc(key, size));
+ }
+
+ private void include2(List<Arc> arcs, Interval span, Int min, Int max,
+ boolean both, boolean maximizing) {
+ include(arcs, span, min, maximizing);
+ if (both) {
+ include(arcs, span.inverse(), max.neg(), maximizing);
+ }
+ }
+
+ private void include2(List<Arc> arcs, Interval span, int min, int max,
+ boolean both, boolean maximizing) {
+ include2(arcs, span, new Int(min), new Int(max), both, maximizing);
+ }
+
+ // Group arcs by their first index, returning an array of arrays.
+ // This is linear in the number of arcs.
+ private Arc[][] index(Arc[] arcs) {
+ int N = getCount() + 1;// the number of vertices
+ Arc[][] result = new Arc[N][];
+ int[] sizes = new int[N];
+ for (Arc arc : arcs) {
+ sizes[arc.span.min]++;
+ }
+ for (int i = 0; i < sizes.length; i++) {
+ result[i] = new Arc[sizes[i]];
+ }
+ // reuse the sizes array to hold the current last elements as we insert each arc
+ Arrays.fill(sizes, 0);
+ for (Arc arc : arcs) {
+ int i = arc.span.min;
+ result[i][sizes[i]++] = arc;
+ }
+
+ return result;
+ }
+
+ // todo do we always add first element?
+ private Arc[] sort(final Arc[] arcs, int start) {
+ final List<Arc> result = new ArrayList<Arc>();
+ new Object() {
+ Arc[][] index = index(arcs);
+ int[] visited = new int[getCount() + 1];
+
+ boolean completesCycle(int loc) {
+ int state = visited[loc];
+ if (state == UNVISITED) {
+ visited[loc] = PENDING;
+ for (Arc arc : index[loc]) {
+ Interval span = arc.span;
+ // the recursive call
+ if (completesCycle(span.max)) {
+ // which arcs get set here is dependent on the order
+ // in which we explore nodes
+ arc.completesCycle = true;
+ }
+ result.add(arc);
+ }
+ visited[loc] = COMPLETE;
+ } else if (state == PENDING) {
+ return true;
+ } else if (state == COMPLETE) {
+ }
+ return false;
+ }
+ }.completesCycle(start);
+ Collections.reverse(result);
+ assert arcs.length == result.size();
+ return result.toArray(new Arc[result.size()]);
+ }
+
+ private boolean[] findUsed(Collection<Arc> arcs) {
+ boolean[] result = new boolean[getCount()];
+ for (Arc arc : arcs) {
+ Interval span = arc.span;
+ int min = min(span.min, span.max);
+ int max = max(span.min, span.max);
+ for (int i = min; i < max; i++) {
+ result[i] = true;
+ }
+ }
+ return result;
+ }
+
+ // todo unify with findUsed above
+ private Collection<Interval> getSpacers() {
+ List<Interval> result = new ArrayList<Interval>();
+ int N = getCount() + 1;
+ int[] leadingEdgeCount = new int[N];
+ int[] trailingEdgeCount = new int[N];
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ LayoutParams lp = getLayoutParams(getChildAt(i));
+ Group g = horizontal ? lp.columnGroup : lp.rowGroup;
+ Interval span = g.span;
+ leadingEdgeCount[span.min]++;
+ trailingEdgeCount[span.max]++;
+ }
+
+ int lastTrailingEdge = 0;
+
+ // treat the parent's edges like peer edges of the opposite type
+ trailingEdgeCount[0] = 1;
+ leadingEdgeCount[N - 1] = 1;
+
+ for (int i = 0; i < N; i++) {
+ if (trailingEdgeCount[i] > 0) {
+ lastTrailingEdge = i;
+ continue; // if this is also a leading edge, don't add a space of length zero
+ }
+ if (leadingEdgeCount[i] > 0) {
+ result.add(new Interval(lastTrailingEdge, i));
+ }
+ }
+ return result;
+ }
+
+ private Arc[] createArcs(boolean maximizing) {
+ List<Arc> spanToSize = new ArrayList<Arc>();
+
+ // Add all the preferred elements that were not defined by the user.
+ PackedMap<Interval, Int> spanSizes = getSpanSizes();
+ for (int i = 0; i < spanSizes.keys.length; i++) {
+ Interval key = spanSizes.keys[i];
+ Int value = spanSizes.values[i];
+ // todo remove value duplicate
+ include2(spanToSize, key, value, value, accommodateBothMinAndMax, maximizing);
+ }
+
+ // Find redundant rows/cols and glue them together with 0-length arcs to link the tree
+ boolean[] used = findUsed(spanToSize);
+ for (int i = 0; i < getCount(); i++) {
+ if (!used[i]) {
+ Interval span = new Interval(i, i + 1);
+ include(spanToSize, span, new Int(0), maximizing);
+ include(spanToSize, span.inverse(), new Int(0), maximizing);
+ }
+ }
+
+ if (mOrderPreserved) {
+ // Add preferred gaps
+ for (int i = 0; i < getCount(); i++) {
+ if (used[i]) {
+ include2(spanToSize, new Interval(i, i + 1), 0, 0, false, maximizing);
+ }
+ }
+ } else {
+ for (Interval gap : getSpacers()) {
+ include2(spanToSize, gap, 0, 0, false, maximizing);
+ }
+ }
+ Arc[] arcs = spanToSize.toArray(new Arc[spanToSize.size()]);
+ return sort(arcs, maximizing ? getCount() : 0);
+ }
+
+ public Arc[] getArcs(boolean maximizing) {
+ if (arcs == null) {
+ arcs = createArcs(maximizing);
+ }
+ if (!arcsValid) {
+ getSpanSizes();
+ arcsValid = true;
+ }
+ return arcs;
+ }
+
+ private boolean relax(int[] locations, Arc entry, boolean maximizing) {
+ Interval span = entry.span;
+ int u = span.min;
+ int v = span.max;
+ int value = entry.value.value;
+ int candidate = locations[u] + value;
+ if (maximizing ? candidate < locations[v] : candidate > locations[v]) {
+ locations[v] = candidate;
+ return true;
+ }
+ return false;
+ }
+
+ // Bellman-Ford variant
+ private int[] solve(Arc[] arcs, int[] locations, boolean maximizing) {
+ int N = getCount() + 1; // The number of vertices is the number of columns/rows + 1.
+
+ boolean changed = false;
+ // We take one extra pass over traditional Bellman-Ford (and omit their final step)
+ for (int i = 0; i < N; i++) {
+ changed = false;
+ for (int j = 0, length = arcs.length; j < length; j++) {
+ changed = changed | relax(locations, arcs[j], maximizing);
+ }
+ if (!changed) {
+ if (DEBUG) {
+ Log.d(TAG, "Iteration " + (maximizing ? "(max)" : "(min)") +
+ " completed after " + (1 + i) + " steps out of " + N);
+ }
+ break;
+ }
+ }
+ if (changed) {
+ Log.d(TAG, "*** Algorithm failed to terminate ***");
+ }
+ return locations;
+ }
+
+ private int[] init(int defaultValue, int min, int max) {
+ int N = getCount() + 1; // The number of vertices is the number of columns/rows + 1.
+ int[] locations = new int[N];
+ Arrays.fill(locations, defaultValue);
+ locations[0] = min;
+ locations[N - 1] = max;
+ return locations;
+ }
+
+ private int[] computeMargins(boolean leading) {
+ int[] result = new int[getCount() + 1];
+ for (int i = 0, size = getChildCount(); i < size; i++) {
+ View c = getChildAt(i);
+ LayoutParams lp = getLayoutParams(c);
+ Group g = horizontal ? lp.columnGroup : lp.rowGroup;
+ Interval span = g.span;
+ int index = leading ? span.min : span.max;
+ result[index] = max(result[index], getMargin(c, leading, horizontal));
+ }
+ return result;
+ }
+
+ // has side effects
+ private void computeLocations(int[] locations, boolean maximizing) {
+ leadingMargins = computeMargins(true);
+ trailingMargins = computeMargins(false);
+
+ solve(getArcs(maximizing), locations, maximizing);
+
+ // Add margins
+ int delta = 0;
+ for (int i = 0; i < getCount(); i++) {
+ int margins = leadingMargins[i] + trailingMargins[i + 1];
+ delta += margins;
+ locations[i + 1] += delta;
+ }
+ }
+
+ private int size(int[] locations) {
+ return locations[locations.length - 1] - locations[0];
+ }
+
+ private int[] getLimit(boolean lowerBound, boolean maximizing) {
+ int defaultValue = maximizing ? MAX_VALUE : MIN_VALUE;
+ if (lowerBound) {
+ // as long as it avoids overflow, the upper bound can be anything (including zero)
+ int[] result = init(defaultValue, defaultValue, 1000);
+ computeLocations(result, maximizing);
+ int delta = result[0];
+ for (int i = 0; i < result.length; i++) {
+ result[i] -= delta;
+ }
+ return result;
+ } else {
+ int[] result = init(defaultValue, 0, defaultValue);
+ computeLocations(result, maximizing);
+ return result;
+ }
+ }
+
+ // External entry points
+
+ private int getMin() {
+ int[] mins = getLimit(maximizing, maximizing);
+ return size(mins);
+ }
+
+ private int getPref() {
+ return accommodateBothMinAndMax ? getMax() : getMin();
+ }
+
+ private int getMax() {
+ int[] maxs = getLimit(!maximizing, maximizing);
+ return size(maxs);
+ }
+
+ private int totalMarginSize() {
+ return sum(leadingMargins) + sum(trailingMargins);
+ }
+
+ private void layout(int targetSize) {
+ int N = getCount() + 1;
+ int min = getMin();
+ int max = getMax();
+
+ int clippedTargetSize = max(min(max, targetSize), min); // confine size to valid range
+
+ if (DEBUG) {
+ Log.d(TAG, "Computing sizes for target " + clippedTargetSize + " for " +
+ (horizontal ? "col" : "row") + "s from: " + arcs);
+ }
+ int delta = clippedTargetSize - min;
+ prefSizeOfWeightedComponent = delta;
+ invalidateValues();
+ int defaultValue = maximizing ? MAX_VALUE : MIN_VALUE;
+ locations = init(defaultValue, 0, clippedTargetSize - totalMarginSize());
+ computeLocations(locations, maximizing);
+ prefSizeOfWeightedComponent = 0;
+
+ if (DEBUG) {
+ Log.d(TAG, "locations = " + Arrays.toString(locations));
+ int[] computedSizes = new int[N - 1];
+ for (int i = 0; i < N - 1; i++) {
+ computedSizes[i] = locations[i + 1] - locations[i];
+ }
+ Log.d(TAG, "sizes = " + Arrays.toString(computedSizes));
+ }
+ }
+
+ private void invalidateStructure() {
+ countValid = false;
+ groupBounds = null;
+ spanSizes = null;
+
+ invalidateValues();
+ }
+
+ private void invalidateValues() {
+ groupBoundsValid = false;
+ spanSizesValid = false;
+ arcsValid = false;
+ }
+ }
+
+ /**
+ * Layout information associated with each of the children of a GridLayout.
+ * <p>
+ * GridLayout supports both row and column spanning and arbitrary forms of alignment within
+ * each cell group. The fundamental parameters associated with each cell group are
+ * gathered into their vertical and horizontal components and stored
+ * in the {@link #rowGroup} and {@link #columnGroup} layout parameters.
+ * {@link Group Groups} are immutable structures and may be shared between the layout
+ * parameters of different children.
+ * <p>
+ * The {@link Group#span span} fields of the row and column groups together specify
+ * the four grid indices that delimit the cells of this cell group.
+ * <p>
+ * The {@link Group#alignment alignment} fields of the row and column groups together specify
+ * both aspects of alignment within the cell group. It is also possible to specify a child's
+ * alignment within its cell group by using the {@link GridLayout.LayoutParams#setGravity(int)}
+ * method.
+ * <p>
+ * See {@link GridLayout} for a description of the conventions used by GridLayout
+ * in reference to grid indices.
+ *
+ * <h4>Default values</h4>
+ *
+ * <ul>
+ * <li>{@link #width} = {@link #WRAP_CONTENT}</li>
+ * <li>{@link #height} = {@link #WRAP_CONTENT}</li>
+ * <li>{@link #topMargin} = 0 when
+ * {@link GridLayout#setUseDefaultMargins(boolean) useDefaultMargins} is
+ * <code>false</code>; otherwise {@link Integer#MIN_VALUE}, to
+ * indicate that a default value should be computed on demand. </li>
+ * <li>{@link #leftMargin} = 0 when
+ * {@link GridLayout#setUseDefaultMargins(boolean) useDefaultMargins} is
+ * <code>false</code>; otherwise {@link Integer#MIN_VALUE}, to
+ * indicate that a default value should be computed on demand. </li>
+ * <li>{@link #bottomMargin} = 0 when
+ * {@link GridLayout#setUseDefaultMargins(boolean) useDefaultMargins} is
+ * <code>false</code>; otherwise {@link Integer#MIN_VALUE}, to
+ * indicate that a default value should be computed on demand. </li>
+ * <li>{@link #rightMargin} = 0 when
+ * {@link GridLayout#setUseDefaultMargins(boolean) useDefaultMargins} is
+ * <code>false</code>; otherwise {@link Integer#MIN_VALUE}, to
+ * indicate that a default value should be computed on demand. </li>
+ * <li>{@link #rowGroup}<code>.span</code> = <code>[0, 1]</code> </li>
+ * <li>{@link #rowGroup}<code>.alignment</code> = {@link #BASELINE} </li>
+ * <li>{@link #columnGroup}<code>.span</code> = <code>[0, 1]</code> </li>
+ * <li>{@link #columnGroup}<code>.alignment</code> = {@link #LEFT} </li>
+ * <li>{@link #rowWeight} = <code>0f</code> </li>
+ * <li>{@link #columnWeight} = <code>0f</code> </li>
+ * </ul>
+ *
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_row
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_rowSpan
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_rowWeight
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_column
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_columnSpan
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_columnWeight
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_gravity
+ */
+ public static class LayoutParams extends MarginLayoutParams {
+
+ // Default values
+
+ private static final int DEFAULT_WIDTH = WRAP_CONTENT;
+ private static final int DEFAULT_HEIGHT = WRAP_CONTENT;
+ private static final int DEFAULT_MARGIN = UNDEFINED;
+ private static final int DEFAULT_ROW = UNDEFINED;
+ private static final int DEFAULT_COLUMN = UNDEFINED;
+ private static final Interval DEFAULT_SPAN = new Interval(0, 1);
+ private static final int DEFAULT_SPAN_SIZE = DEFAULT_SPAN.size();
+ private static final Alignment DEFAULT_HORIZONTAL_ALIGNMENT = LEFT;
+ private static final Alignment DEFAULT_VERTCIAL_ALGIGNMENT = BASELINE;
+ private static final Group DEFAULT_HORIZONTAL_GROUP =
+ new Group(DEFAULT_SPAN, DEFAULT_HORIZONTAL_ALIGNMENT);
+ private static final Group DEFAULT_VERTICAL_GROUP =
+ new Group(DEFAULT_SPAN, DEFAULT_VERTCIAL_ALGIGNMENT);
+ private static final int DEFAULT_WEIGHT = 0;
+
+ // Misc
+
+ private static final Rect CONTAINER_BOUNDS = new Rect(0, 0, 2, 2);
+ private static final Alignment[] HORIZONTAL_ALIGNMENTS = { LEFT, CENTER, RIGHT };
+ private static final Alignment[] VERTICAL_ALIGNMENTS = { TOP, CENTER, BOTTOM };
+
+ // TypedArray indices
+
+ private static final int MARGIN = styleable.ViewGroup_MarginLayout_layout_margin;
+ private static final int LEFT_MARGIN = styleable.ViewGroup_MarginLayout_layout_marginLeft;
+ private static final int TOP_MARGIN = styleable.ViewGroup_MarginLayout_layout_marginTop;
+ private static final int RIGHT_MARGIN = styleable.ViewGroup_MarginLayout_layout_marginRight;
+ private static final int BOTTOM_MARGIN =
+ styleable.ViewGroup_MarginLayout_layout_marginBottom;
+
+ private static final int COLUMN = styleable.GridLayout_Layout_layout_column;
+ private static final int COLUMN_SPAN = styleable.GridLayout_Layout_layout_columnSpan;
+ private static final int COLUMN_WEIGHT = styleable.GridLayout_Layout_layout_columnWeight;
+ private static final int ROW = styleable.GridLayout_Layout_layout_row;
+ private static final int ROW_SPAN = styleable.GridLayout_Layout_layout_rowSpan;
+ private static final int ROW_WEIGHT = styleable.GridLayout_Layout_layout_rowWeight;
+ private static final int GRAVITY = styleable.GridLayout_Layout_layout_gravity;
+
+ // Instance variables
+
+ /**
+ * The group that specifies the vertical characteristics of the cell group
+ * described by these layout parameters.
+ */
+ public Group rowGroup;
+ /**
+ * The group that specifies the horizontal characteristics of the cell group
+ * described by these layout parameters.
+ */
+ public Group columnGroup;
+ /**
+ * The proportional space that should be taken by the associated row group
+ * during excess space distribution.
+ */
+ public float rowWeight;
+ /**
+ * The proportional space that should be taken by the associated column group
+ * during excess space distribution.
+ */
+ public float columnWeight;
+
+ // Constructors
+
+ private LayoutParams(
+ int width, int height,
+ int left, int top, int right, int bottom,
+ Group rowGroup, Group columnGroup, float rowWeight, float columnWeight) {
+ super(width, height);
+ setMargins(left, top, right, bottom);
+ this.rowGroup = rowGroup;
+ this.columnGroup = columnGroup;
+ this.rowWeight = rowWeight;
+ this.columnWeight = columnWeight;
+ }
+
+ /**
+ * Constructs a new LayoutParams instance for this <code>rowGroup</code>
+ * and <code>columnGroup</code>. All other fields are initialized with
+ * default values as defined in {@link LayoutParams}.
+ *
+ * @param rowGroup the rowGroup
+ * @param columnGroup the columnGroup
+ */
+ public LayoutParams(Group rowGroup, Group columnGroup) {
+ this(DEFAULT_WIDTH, DEFAULT_HEIGHT,
+ DEFAULT_MARGIN, DEFAULT_MARGIN, DEFAULT_MARGIN, DEFAULT_MARGIN,
+ rowGroup, columnGroup, DEFAULT_WEIGHT, DEFAULT_WEIGHT);
+ }
+
+ /**
+ * Constructs a new LayoutParams with default values as defined in {@link LayoutParams}.
+ */
+ public LayoutParams() {
+ this(DEFAULT_HORIZONTAL_GROUP, DEFAULT_VERTICAL_GROUP);
+ }
+
+ // Copying constructors
+
+ /**
+ * {@inheritDoc}
+ */
+ public LayoutParams(ViewGroup.LayoutParams params) {
+ super(params);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public LayoutParams(MarginLayoutParams params) {
+ super(params);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public LayoutParams(LayoutParams that) {
+ super(that);
+ this.columnGroup = that.columnGroup;
+ this.rowGroup = that.rowGroup;
+ this.columnWeight = that.columnWeight;
+ this.rowWeight = that.rowWeight;
+ }
+
+ // AttributeSet constructors
+
+ private LayoutParams(Context context, AttributeSet attrs, int defaultGravity) {
+ super(context, attrs);
+ reInitSuper(context, attrs);
+ init(context, attrs, defaultGravity);
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Values not defined in the attribute set take the default values
+ * defined in {@link LayoutParams}.
+ */
+ public LayoutParams(Context context, AttributeSet attrs) {
+ this(context, attrs, Gravity.NO_GRAVITY);
+ }
+
+ // Implementation
+
+ private static boolean definesVertical(int gravity) {
+ return gravity > 0 && (gravity & Gravity.VERTICAL_GRAVITY_MASK) != 0;
+ }
+
+ private static boolean definesHorizontal(int gravity) {
+ return gravity > 0 && (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) != 0;
+ }
+
+ private static <T> T getAlignment(T[] alignments, T fill, int min, int max,
+ boolean isUndefined, T defaultValue) {
+ if (isUndefined) {
+ return defaultValue;
+ }
+ return min != max ? fill : alignments[min];
+ }
+
+ // Reinitialise the margins using a different default policy than MarginLayoutParams.
+ // Here we use the value UNDEFINED (as distinct from zero) to represent the undefined state
+ // so that a layout manager default can be accessed post set up. We need this as, at the
+ // point of installation, we do not know how many rows/cols there are and therefore
+ // which elements are positioned next to the container's trailing edges. We need to
+ // know this as margins around the container's boundary should have different
+ // defaults to those between peers.
+
+ // This method could be parametrized and moved into MarginLayout.
+ private void reInitSuper(Context context, AttributeSet attrs) {
+ TypedArray a = context.obtainStyledAttributes(attrs, styleable.ViewGroup_MarginLayout);
+ try {
+ int margin = a.getDimensionPixelSize(MARGIN, DEFAULT_MARGIN);
+
+ this.leftMargin = a.getDimensionPixelSize(LEFT_MARGIN, margin);
+ this.topMargin = a.getDimensionPixelSize(TOP_MARGIN, margin);
+ this.rightMargin = a.getDimensionPixelSize(RIGHT_MARGIN, margin);
+ this.bottomMargin = a.getDimensionPixelSize(BOTTOM_MARGIN, margin);
+ } finally {
+ a.recycle();
+ }
+ }
+
+ // Gravity. For conversion from the static the integers defined in the Gravity class,
+ // use Gravity.apply() to apply gravity to a view of zero size and see where it ends up.
+ private static Alignment getHorizontalAlignment(int gravity, int width) {
+ Rect r = new Rect(0, 0, 0, 0);
+ Gravity.apply(gravity, 0, 0, CONTAINER_BOUNDS, r);
+
+ boolean fill = width == MATCH_PARENT;
+ Alignment defaultAlignment = fill ? FILL : DEFAULT_HORIZONTAL_ALIGNMENT;
+ return getAlignment(HORIZONTAL_ALIGNMENTS, FILL, r.left, r.right,
+ !definesHorizontal(gravity), defaultAlignment);
+ }
+
+ private static Alignment getVerticalAlignment(int gravity, int height) {
+ Rect r = new Rect(0, 0, 0, 0);
+ Gravity.apply(gravity, 0, 0, CONTAINER_BOUNDS, r);
+
+ boolean fill = height == MATCH_PARENT;
+ Alignment defaultAlignment = fill ? FILL : DEFAULT_VERTCIAL_ALGIGNMENT;
+ return getAlignment(VERTICAL_ALIGNMENTS, FILL, r.top, r.bottom,
+ !definesVertical(gravity), defaultAlignment);
+ }
+
+ private void init(Context context, AttributeSet attrs, int defaultGravity) {
+ TypedArray a = context.obtainStyledAttributes(attrs, styleable.GridLayout_Layout);
+ try {
+ int gravity = a.getInteger(GRAVITY, defaultGravity);
+
+ int column = a.getInteger(COLUMN, DEFAULT_COLUMN);
+ int width = a.getInteger(COLUMN_SPAN, DEFAULT_SPAN_SIZE);
+ Interval colSpan = new Interval(column, column + width);
+ this.columnGroup = new Group(colSpan, getHorizontalAlignment(gravity, width));
+ this.columnWeight = a.getFloat(COLUMN_WEIGHT, DEFAULT_WEIGHT);
+
+ int row = a.getInteger(ROW, DEFAULT_ROW);
+ int height = a.getInteger(ROW_SPAN, DEFAULT_SPAN_SIZE);
+ Interval rowSpan = new Interval(row, row + height);
+ this.rowGroup = new Group(rowSpan, getVerticalAlignment(gravity, height));
+ this.rowWeight = a.getFloat(ROW_WEIGHT, DEFAULT_WEIGHT);
+ } finally {
+ a.recycle();
+ }
+ }
+
+ /**
+ * Describes how the child views are positioned. Default is <code>LEFT | BASELINE</code>.
+ *
+ * @param gravity the new gravity. See {@link android.view.Gravity}.
+ *
+ * @attr ref android.R.styleable#GridLayout_Layout_layout_gravity
+ */
+ public void setGravity(int gravity) {
+ columnGroup = columnGroup.copyWriteAlignment(getHorizontalAlignment(gravity, width));
+ rowGroup = rowGroup.copyWriteAlignment(getVerticalAlignment(gravity, height));
+ }
+
+ @Override
+ protected void setBaseAttributes(TypedArray attributes, int widthAttr, int heightAttr) {
+ this.width = attributes.getLayoutDimension(widthAttr, DEFAULT_WIDTH);
+ this.height = attributes.getLayoutDimension(heightAttr, DEFAULT_HEIGHT);
+ }
+
+ private void setVerticalGroupSpan(Interval span) {
+ rowGroup = rowGroup.copyWriteSpan(span);
+ }
+
+ private void setHorizontalGroupSpan(Interval span) {
+ columnGroup = columnGroup.copyWriteSpan(span);
+ }
+ }
+
+ private static class Arc {
+ public final Interval span;
+ public final Int value;
+ public boolean completesCycle;
+
+ public Arc(Interval span, Int value) {
+ this.span = span;
+ this.value = value;
+ }
+
+ @Override
+ public String toString() {
+ return span + " " + (completesCycle ? "+>" : "->") + " " + value;
+ }
+ }
+
+ // A mutable Integer - used to avoid heap allocation during the layout operation
+
+ private static class Int {
+ public int value;
+
+ private Int() {
+ reset();
+ }
+
+ private Int(int value) {
+ this.value = value;
+ }
+
+ private void reset() {
+ value = Integer.MIN_VALUE;
+ }
+
+ private Int neg() {
+ // this should never be called
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ @SuppressWarnings(value = "unchecked")
+ private static class PackedMap<K, V> {
+ public final int[] index;
+ public final K[] keys;
+ public final V[] values;
+
+ private PackedMap(K[] keys, V[] values) {
+ this.index = createIndex(keys);
+
+ this.keys = index(keys, index);
+ this.values = index(values, index);
+ }
+
+ private K getKey(int i) {
+ return keys[index[i]];
+ }
+
+ private V getValue(int i) {
+ return values[index[i]];
+ }
+
+ private static <K> int[] createIndex(K[] keys) {
+ int size = keys.length;
+ int[] result = new int[size];
+
+ Map<K, Integer> keyToIndex = new HashMap<K, Integer>();
+ for (int i = 0; i < size; i++) {
+ K key = keys[i];
+ Integer index = keyToIndex.get(key);
+ if (index == null) {
+ index = keyToIndex.size();
+ keyToIndex.put(key, index);
+ }
+ result[i] = index;
+ }
+ return result;
+ }
+
+ private static int max(int[] a, int valueIfEmpty) {
+ int result = valueIfEmpty;
+ for (int i = 0, length = a.length; i < length; i++) {
+ result = Math.max(result, a[i]);
+ }
+ return result;
+ }
+
+ private static <K> K[] index(K[] keys, int[] index) {
+ int size = keys.length;
+ Class<?> componentType = keys.getClass().getComponentType();
+ K[] result = (K[]) Array.newInstance(componentType, max(index, -1) + 1);
+
+ // this overwrite duplicates, retaining the last equivalent entry
+ for (int i = 0; i < size; i++) {
+ result[index[i]] = keys[i];
+ }
+ return result;
+ }
+ }
+
+ private static class Bounds {
+ public int below;
+ public int above;
+
+ private Bounds(int below, int above) {
+ this.below = below;
+ this.above = above;
+ }
+
+ private Bounds() {
+ reset();
+ }
+
+ private void reset() {
+ below = Integer.MAX_VALUE;
+ above = Integer.MIN_VALUE;
+ }
+
+ private void include(int below, int above) {
+ this.below = min(this.below, below);
+ this.above = max(this.above, above);
+ }
+
+ private int size() {
+ return above - below;
+ }
+
+ @Override
+ public String toString() {
+ return "Bounds{" +
+ "below=" + below +
+ ", above=" + above +
+ '}';
+ }
+ }
+
+ /**
+ * An Interval represents a contiguous range of values that lie between
+ * the interval's {@link #min} and {@link #max} values.
+ * <p>
+ * Intervals are immutable so may be passed as values and used as keys in hash tables.
+ * It is not necessary to have multiple instances of Intervals which have the same
+ * {@link #min} and {@link #max} values.
+ * <p>
+ * Intervals are often written as <code>[min, max]</code> and represent the set of values
+ * <em>x</em> such that <em>min <= x < max</em>.
+ */
+ public static class Interval {
+ /**
+ * The minimum value.
+ */
+ public final int min;
+ /**
+ * The maximum value.
+ */
+ public final int max;
+
+ /**
+ * Construct a new Interval, <code>interval</code>, where:
+ * <ul>
+ * <li> <code>interval.min = min</code> </li>
+ * <li> <code>interval.max = max</code> </li>
+ * </ul>
+ *
+ * @param min the minimum value.
+ * @param max the maximum value.
+ */
+ public Interval(int min, int max) {
+ this.min = min;
+ this.max = max;
+ }
+
+ private int size() {
+ return max - min;
+ }
+
+ private Interval inverse() {
+ return new Interval(max, min);
+ }
+
+ /**
+ * Returns true if the {@link #getClass class}, {@link #min} and {@link #max} properties
+ * of this Interval and the supplied parameter are pairwise equal; false otherwise.
+ *
+ * @param that the object to compare this interval with.
+ *
+ * @return {@code true} if the specified object is equal to this
+ * {@code Interval}; {@code false} otherwise.
+ */
+ @Override
+ public boolean equals(Object that) {
+ if (this == that) {
+ return true;
+ }
+ if (that == null || getClass() != that.getClass()) {
+ return false;
+ }
+
+ Interval interval = (Interval) that;
+
+ if (max != interval.max) {
+ return false;
+ }
+ if (min != interval.min) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = min;
+ result = 31 * result + max;
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "[" + min + ", " + max + "]";
+ }
+ }
+
+ /**
+ * A group specifies either the horizontal or vertical characteristics of a group of
+ * cells.
+ * <p>
+ * Groups are immutable and so may be shared between views with the same
+ * <code>span</code> and <code>alignment</code>.
+ */
+ public static class Group {
+ /**
+ * The {@link Interval#min min} and {@link Interval#max max} values of
+ * a span specify the grid indices of the leading and trailing edges of
+ * the cell group.
+ * <p>
+ * See {@link GridLayout} for a description of the conventions used by GridLayout
+ * for grid indices.
+ */
+ public final Interval span;
+ /**
+ * Specifies how cells should be aligned in this group.
+ * For row groups, this specifies the vertical alignment.
+ * For column groups, this specifies the horizontal alignment.
+ */
+ public final Alignment alignment;
+
+ /**
+ * Construct a new Group, <code>group</code>, where:
+ * <ul>
+ * <li> <code>group.span = span</code> </li>
+ * <li> <code>group.alignment = alignment</code> </li>
+ * </ul>
+ *
+ * @param span the span.
+ * @param alignment the alignment.
+ */
+ public Group(Interval span, Alignment alignment) {
+ this.span = span;
+ this.alignment = alignment;
+ }
+
+ /**
+ * Construct a new Group, <code>group</code>, where:
+ * <ul>
+ * <li> <code>group.span = [min, max]</code> </li>
+ * <li> <code>group.alignment = alignment</code> </li>
+ * </ul>
+ *
+ * @param min the minimum.
+ * @param max the maximum.
+ * @param alignment the alignment.
+ */
+ public Group(int min, int max, Alignment alignment) {
+ this(new Interval(min, max), alignment);
+ }
+
+ /**
+ * Construct a new Group, <code>group</code>, where:
+ * <ul>
+ * <li> <code>group.span = [min, min + 1]</code> </li>
+ * <li> <code>group.alignment = alignment</code> </li>
+ * </ul>
+ *
+ * @param min the minimum.
+ * @param alignment the alignment.
+ */
+ public Group(int min, Alignment alignment) {
+ this(min, min + 1, alignment);
+ }
+
+ private Group copyWriteSpan(Interval span) {
+ return new Group(span, alignment);
+ }
+
+ private Group copyWriteAlignment(Alignment alignment) {
+ return new Group(span, alignment);
+ }
+
+ /**
+ * Returns true if the {@link #getClass class}, {@link #alignment} and {@link #span}
+ * properties of this Group and the supplied parameter are pairwise equal; false otherwise.
+ *
+ * @param that the object to compare this group with.
+ *
+ * @return {@code true} if the specified object is equal to this
+ * {@code Group}; {@code false} otherwise.
+ */
+ @Override
+ public boolean equals(Object that) {
+ if (this == that) {
+ return true;
+ }
+ if (that == null || getClass() != that.getClass()) {
+ return false;
+ }
+
+ Group group = (Group) that;
+
+ if (!alignment.equals(group.alignment)) {
+ return false;
+ }
+ if (!span.equals(group.span)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result = span.hashCode();
+ result = 31 * result + alignment.hashCode();
+ return result;
+ }
+ }
+
+ // Alignments
+
+
+ /**
+ * Alignments specify where a view should be placed within a cell group and
+ * what size it should be.
+ * <p>
+ * The {@link LayoutParams} class contains a {@link LayoutParams#rowGroup rowGroup}
+ * and a {@link LayoutParams#columnGroup columnGroup} each of which contains an
+ * {@link Group#alignment alignment}. Overall placement of the view in the cell
+ * group is specified by the two alignments which act along each axis independently.
+ * <p>
+ * An Alignment implementation must define the {@link #getAlignmentValue(View, int)}
+ * to return the appropriate value for the type of alignment being defined.
+ * The enclosing algorithms position the children
+ * so that the values returned from the alignment
+ * are the same for all of the views in a group.
+ * <p>
+ * The GridLayout class defines the most common alignments used in general layout:
+ * {@link #TOP}, {@link #LEFT}, {@link #BOTTOM}, {@link #RIGHT}, {@link #CENTER}, {@link
+ * #BASELINE} and {@link #FILL}.
+ */
+ public static interface Alignment {
+ /**
+ * Returns an alignment value. In the case of vertical alignments the value
+ * returned should indicate the distance from the top of the view to the
+ * alignment location.
+ * For horizontal alignments measurement is made from the left edge of the component.
+ *
+ * @param view the view to which this alignment should be applied.
+ * @param viewSize the measured size of the view.
+ * @return the alignment value.
+ */
+ public int getAlignmentValue(View view, int viewSize);
+
+ /**
+ * Returns the size of the view specified by this alignment.
+ * In the case of vertical alignments this method should return a height; for
+ * horizontal alignments this method should return the width.
+ *
+ * @param view the view to which this alignment should be applied.
+ * @param viewSize the measured size of the view.
+ * @param cellSize the size of the cell into which this view will be placed.
+ * @return the aligned size.
+ */
+ public int getSizeInCell(View view, int viewSize, int cellSize);
+ }
+
+ private static abstract class AbstractAlignment implements Alignment {
+ public int getSizeInCell(View view, int viewSize, int cellSize) {
+ return viewSize;
+ }
+ }
+
+ private static final Alignment LEADING = new AbstractAlignment() {
+ public int getAlignmentValue(View view, int viewSize) {
+ return 0;
+ }
+
+ };
+
+ private static final Alignment TRAILING = new AbstractAlignment() {
+ public int getAlignmentValue(View view, int viewSize) {
+ return viewSize;
+ }
+ };
+
+ /**
+ * Indicates that a view should be aligned with the <em>top</em>
+ * edges of the other views in its cell group.
+ */
+ public static final Alignment TOP = LEADING;
+
+ /**
+ * Indicates that a view should be aligned with the <em>bottom</em>
+ * edges of the other views in its cell group.
+ */
+ public static final Alignment BOTTOM = TRAILING;
+
+ /**
+ * Indicates that a view should be aligned with the <em>right</em>
+ * edges of the other views in its cell group.
+ */
+ public static final Alignment RIGHT = TRAILING;
+
+ /**
+ * Indicates that a view should be aligned with the <em>left</em>
+ * edges of the other views in its cell group.
+ */
+ public static final Alignment LEFT = LEADING;
+
+ /**
+ * Indicates that a view should be <em>centered</em> with the other views in its cell group.
+ * This constant may be used in both {@link LayoutParams#rowGroup rowGroups} and {@link
+ * LayoutParams#columnGroup columnGroups}.
+ */
+ public static final Alignment CENTER = new AbstractAlignment() {
+ public int getAlignmentValue(View view, int viewSize) {
+ return viewSize >> 1;
+ }
+ };
+
+ /**
+ * Indicates that a view should be aligned with the <em>baselines</em>
+ * of the other views in its cell group.
+ * This constant may only be used as an alignment in {@link LayoutParams#rowGroup rowGroups}.
+ *
+ * @see View#getBaseline()
+ */
+ public static final Alignment BASELINE = new AbstractAlignment() {
+ public int getAlignmentValue(View view, int viewSize) {
+ if (view == null) {
+ return UNDEFINED;
+ }
+ // todo do we need to call measure first?
+ int baseline = view.getBaseline();
+ return baseline == -1 ? UNDEFINED : baseline;
+ }
+
+ };
+
+ /**
+ * Indicates that a view should expanded to fit the boundaries of its cell group.
+ * This constant may be used in both {@link LayoutParams#rowGroup rowGroups} and
+ * {@link LayoutParams#columnGroup columnGroups}.
+ */
+ public static final Alignment FILL = new Alignment() {
+ public int getAlignmentValue(View view, int viewSize) {
+ return UNDEFINED;
+ }
+
+ public int getSizeInCell(View view, int viewSize, int cellSize) {
+ return cellSize;
+ }
+ };
+}
\ No newline at end of file
diff --git a/core/java/android/widget/Space.java b/core/java/android/widget/Space.java
new file mode 100644
index 0000000..d98b937
--- /dev/null
+++ b/core/java/android/widget/Space.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2011 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.widget;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+import android.view.View;
+import android.view.ViewGroup;
+
+/**
+ * Space is a lightweight View subclass that may be used to create gaps between components
+ * in general purpose layouts.
+ */
+public final class Space extends View {
+ /**
+ * {@inheritDoc}
+ */
+ public Space(Context context, AttributeSet attrs, int defStyle) {
+ super(context, attrs, defStyle);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Space(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ public Space(Context context) {
+ super(context);
+ }
+
+ /**
+ * Draw nothing.
+ *
+ * @param canvas an unused parameter.
+ */
+ @Override
+ public void draw(Canvas canvas) {
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public ViewGroup.LayoutParams getLayoutParams() {
+ return super.getLayoutParams();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setLayoutParams(ViewGroup.LayoutParams params) {
+ super.setLayoutParams(params);
+ }
+}
diff --git a/core/res/res/values/attrs.xml b/core/res/res/values/attrs.xml
index c1e81c3..f854e93 100755
--- a/core/res/res/values/attrs.xml
+++ b/core/res/res/values/attrs.xml
@@ -2429,6 +2429,36 @@
<!-- Size of padding on either end of a divider. -->
<attr name="dividerPadding" format="dimension" />
</declare-styleable>
+ <declare-styleable name="GridLayout">
+ <!-- The orientation property is not used during layout. It is only used to
+ allocate row and column prameters when they are not specified by its children's
+ layout paramters. GridLayout works like LinearLayout in this case;
+ putting all the components either in a single row or in a single column -
+ depending on the value of this flag. In the horozintal case, a columnCount
+ property may be additionally supplied to force new rows to be created when a
+ row is full. The rowCount attribute may be used similarly in the vertical case.
+ The default is horizontal. -->
+ <attr name="orientation" />
+ <!-- The maxmimum number of rows to create when automatically positioning children. -->
+ <attr name="rowCount" format="integer" />
+ <!-- The maxmimum number of columns to create when automatically positioning children. -->
+ <attr name="columnCount" format="integer" />
+ <!-- When set to true, tells GridLayout to use default margins when none are specified
+ in a view's layout parameters.
+ The default value is false.
+ See {@link android.widget.GridLayout#setUseDefaultMargins(boolean)}.-->
+ <attr name="useDefaultMargins" format="boolean" />
+ <!-- When set to true, forces row boundaries to appear in the same order
+ as row indices.
+ The default is false.
+ See {@link android.widget.GridLayout#setRowOrderPreserved(boolean)}.-->
+ <attr name="rowOrderPreserved" format="boolean" />
+ <!-- When set to true, forces column boundaries to appear in the same order
+ as column indices.
+ The default is false.
+ See {@link android.widget.GridLayout#setColumnOrderPreserved(boolean)}.-->
+ <attr name="columnOrderPreserved" format="boolean" />
+ </declare-styleable>
<declare-styleable name="ListView">
<!-- Reference to an array resource that will populate the ListView. For static content,
this is simpler than populating the ListView programmatically. -->
@@ -3128,6 +3158,38 @@
<attr name="layout_weight" format="float" />
<attr name="layout_gravity" />
</declare-styleable>
+ <declare-styleable name="GridLayout_Layout">
+ <!-- The row boundary delimiting the top of the group of cells
+ occupied by this view. -->
+ <attr name="layout_row" format="integer" />
+ <!-- The row span: the difference between the bottom and top
+ boundaries delimiting the group of cells occupied by this view.
+ The default is one.
+ See {@link android.widget.GridLayout.Group#span}. -->
+ <attr name="layout_rowSpan" format="integer" min="1" />
+ <!-- A number indicating the relative proportion of availible space that
+ should be taken by this group of cells.
+ The default is zero.
+ See {@link android.widget.GridLayout.LayoutParams#columnWeight}. -->
+ <attr name="layout_rowWeight" format="float" />
+ <!-- The column boundary delimiting the left of the group of cells
+ occupied by this view. -->
+ <attr name="layout_column" />
+ <!-- The column span: the difference between the right and left
+ boundaries delimiting the group of cells occupied by this view.
+ The default is one.
+ See {@link android.widget.GridLayout.Group#span}. -->
+ <attr name="layout_columnSpan" format="integer" min="1" />
+ <!-- A number indicating the relative proportion of availible space that
+ should be taken by this group of cells.
+ The default is zero.
+ See {@link android.widget.GridLayout.LayoutParams#columnWeight}.-->
+ <attr name="layout_columnWeight" format="float" />
+ <!-- Gravity specifies how a component should be placed in its group of cells.
+ The default is LEFT | BASELINE.
+ See {@link android.widget.GridLayout.LayoutParams#setGravity(int)}. -->
+ <attr name="layout_gravity" />
+ </declare-styleable>
<declare-styleable name="FrameLayout_Layout">
<attr name="layout_gravity" />
</declare-styleable>
diff --git a/core/res/res/values/public.xml b/core/res/res/values/public.xml
index 1957b2a..0bd939ed 100644
--- a/core/res/res/values/public.xml
+++ b/core/res/res/values/public.xml
@@ -1672,4 +1672,17 @@
<public type="attr" name="fullBackupAgent" />
<public type="attr" name="suggestionsEnabled" />
+ <public type="attr" name="rowCount" />
+ <public type="attr" name="rowOrderPreserved" />
+ <public type="attr" name="columnCount" />
+ <public type="attr" name="columnOrderPreserved" />
+ <public type="attr" name="useDefaultMargins" />
+
+ <public type="attr" name="layout_row" />
+ <public type="attr" name="layout_rowSpan" />
+
+ <public type="attr" name="layout_rowWeight" />
+ <public type="attr" name="layout_columnSpan" />
+ <public type="attr" name="layout_columnWeight" />
+
</resources>
diff --git a/tests/GridLayoutTest/Android.mk b/tests/GridLayoutTest/Android.mk
new file mode 100644
index 0000000..a02918b
--- /dev/null
+++ b/tests/GridLayoutTest/Android.mk
@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2010 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(call all-subdir-java-files)
+
+LOCAL_PACKAGE_NAME := GridLayoutTest
+
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_PACKAGE)
diff --git a/tests/GridLayoutTest/AndroidManifest.xml b/tests/GridLayoutTest/AndroidManifest.xml
new file mode 100644
index 0000000..53ca4ce
--- /dev/null
+++ b/tests/GridLayoutTest/AndroidManifest.xml
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2010 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.test.layout">
+
+ <uses-permission android:name="android.permission.INTERNET"/>
+ <uses-sdk android:minSdkVersion="11"/>
+
+ <application>
+ <activity android:name="Activity0" android:label="Activity0">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity1" android:label="Activity1">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity2" android:label="Activity2">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity3" android:label="Activity3">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity4" android:label="Activity4">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity5" android:label="Activity5">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity6" android:label="Activity6">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+
+ <activity android:name="Activity7" android:label="Activity7">
+ <intent-filter>
+ <action android:name="android.intent.action.MAIN"/>
+ <category android:name="android.intent.category.LAUNCHER"/>
+ </intent-filter>
+ </activity>
+ </application>
+
+
+</manifest>
diff --git a/tests/GridLayoutTest/res/layout/grid0.xml b/tests/GridLayoutTest/res/layout/grid0.xml
new file mode 100644
index 0000000..1c291f0
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid0.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
+ android:layout_width="fill_parent"
+ android:layout_height="fill_parent">
+</GridLayout>
\ No newline at end of file
diff --git a/tests/GridLayoutTest/res/layout/grid3.xml b/tests/GridLayoutTest/res/layout/grid3.xml
new file mode 100644
index 0000000..ace7b4c
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid3.xml
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<GridLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+ >
+
+ <Button
+ android:text="fill"
+ android:width="200dip"
+ android:height="100dip"
+ android:layout_marginLeft="50dip"
+ android:layout_row="0"
+ android:layout_column="0"
+ android:layout_gravity="fill_horizontal"
+ />
+
+ <EditText
+ android:layout_row="0"
+ android:layout_column="1"
+ />
+
+ <Button
+ android:text="left"
+ android:layout_row="1"
+ android:layout_column="0"
+ />
+
+ <EditText
+ android:layout_row="1"
+ android:layout_column="1"
+ />
+
+ <Button
+ android:text="right"
+ android:layout_row="2"
+ android:layout_column="0"
+ android:layout_gravity="right"
+ />
+
+ <EditText
+ android:layout_margin="50dip"
+ android:textSize="100dip"
+ android:layout_row="2"
+ android:layout_column="1"
+ />
+
+ <Button
+ android:text="center"
+ android:layout_row="3"
+ android:layout_column="0"
+ android:layout_gravity="center_horizontal"
+ />
+
+ <EditText
+ android:layout_height="fill_parent"
+ android:layout_row="3"
+ android:layout_column="1"
+ />
+
+</GridLayout>
diff --git a/tests/GridLayoutTest/res/layout/grid4.xml b/tests/GridLayoutTest/res/layout/grid4.xml
new file mode 100644
index 0000000..116a256
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid4.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<GridLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+ <Button
+ android:text="fill"
+ android:layout_margin="100dip"
+ android:layout_marginLeft="100dip"
+ android:layout_marginBottom="100dip"
+ android:layout_marginTop="100dip"
+ android:layout_marginRight="100dip"
+ android:layout_row="0"
+ android:layout_column="0"
+ android:layout_gravity="fill_horizontal"
+ />
+</GridLayout>
diff --git a/tests/GridLayoutTest/res/layout/grid5.xml b/tests/GridLayoutTest/res/layout/grid5.xml
new file mode 100644
index 0000000..9b87f18
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid5.xml
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<GridLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+
+ android:orientation="horizontal"
+ android:columnCount="2"
+ >
+
+ <TextView
+ android:text="Name:"
+ />
+
+ <EditText
+ android:text="fill"
+ android:width="200dip"
+ android:height="100dip"
+ android:layout_marginLeft="50dip"
+ android:layout_gravity="fill_horizontal"
+ />
+
+ <TextView
+ />
+
+<!--
+ <TextView
+ android:layout_row_weight="1"
+ android:layout_column_weight="1"
+ />
+-->
+
+ <EditText
+ android:text="left"
+ />
+
+ <EditText/>
+
+ <EditText
+ android:text="right"
+ android:layout_gravity="right"
+ />
+
+ <EditText
+ android:layout_margin="50dip"
+ android:textSize="100dip"
+ />
+
+ <Button
+ android:text="center"
+ android:layout_gravity="center_horizontal"
+ />
+
+ <EditText
+ android:layout_height="fill_parent"
+ />
+
+</GridLayout>
diff --git a/tests/GridLayoutTest/res/layout/grid6.xml b/tests/GridLayoutTest/res/layout/grid6.xml
new file mode 100644
index 0000000..7486a2d
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid6.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2011 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.
+-->
+
+<GridLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+
+ android:layout_width="match_parent"
+ android:layout_height="match_parent"
+
+ android:columnCount="2"
+ android:useDefaultMargins="true"
+ >
+
+ <TextView android:text="Name:"/>
+
+ <EditText/>
+
+ <TextView android:text="Rank:"/>
+
+ <EditText/>
+
+ <TextView android:text="Serial Number:"/>
+
+ <EditText/>
+
+</GridLayout>
diff --git a/tests/GridLayoutTest/res/layout/grid7.xml b/tests/GridLayoutTest/res/layout/grid7.xml
new file mode 100644
index 0000000..b97a00b
--- /dev/null
+++ b/tests/GridLayoutTest/res/layout/grid7.xml
@@ -0,0 +1,71 @@
+<!-- Copyright (C) 2010 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<GridLayout
+ xmlns:android="http://schemas.android.com/apk/res/android"
+
+ android:orientation="vertical"
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:paddingTop="10dip" >
+
+ <TextView
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:paddingRight="5dip"
+ android:text="flabe" />
+
+ <Button android:id="@+id/initialActivity"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:text="bax" />
+ </LinearLayout>
+
+ <LinearLayout
+ android:orientation="horizontal"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:paddingTop="5dip" >
+
+ <TextView
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:paddingRight="5dip"
+ android:text="bar" />
+
+ <EditText android:id="@+id/numberOfEvents"
+ android:layout_marginLeft="2dip"
+ android:layout_width="match_parent"
+ android:layout_height="wrap_content"
+ android:background="@android:drawable/editbox_background"
+ android:numeric="integer"
+ android:scrollHorizontally="true"
+ android:maxLines="1" />
+ </LinearLayout>
+
+ <Button android:id="@+id/start"
+ android:layout_width="wrap_content"
+ android:layout_height="wrap_content"
+ android:paddingTop="10dip"
+ android:text="Foo" />
+
+</GridLayout>
+
+
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity0.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity0.java
new file mode 100644
index 0000000..660c1c3
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity0.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity0 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid0);
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity1.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity1.java
new file mode 100644
index 0000000..e6645f5
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity1.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.widget.GridLayout;
+
+public class Activity1 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(new GridLayout(getBaseContext()));
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity2.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity2.java
new file mode 100644
index 0000000..6359903
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity2.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+
+import android.widget.*;
+
+import static android.text.InputType.TYPE_CLASS_TEXT;
+import static android.view.inputmethod.EditorInfo.*;
+import static android.widget.GridLayout.*;
+
+public class Activity2 extends Activity {
+
+ public static View create(Context context) {
+ GridLayout vg = new GridLayout(context);
+ vg.setUseDefaultMargins(true);
+
+ Group row1 = new Group(1, CENTER);
+ Group row2 = new Group(2, CENTER);
+ Group row3 = new Group(3, BASELINE);
+ Group row4 = new Group(4, BASELINE);
+ Group row5 = new Group(5, FILL);
+ Group row6 = new Group(6, CENTER);
+ Group row7 = new Group(7, CENTER);
+
+ Group col1a = new Group(1, 5, CENTER);
+ Group col1b = new Group(1, 5, LEFT);
+ Group col1c = new Group(1, RIGHT);
+ Group col2 = new Group(2, LEFT);
+ Group col3 = new Group(3, FILL);
+ Group col4 = new Group(4, FILL);
+
+ {
+ TextView v = new TextView(context);
+ v.setTextSize(48);
+ v.setText("Email setup");
+ vg.addView(v, new LayoutParams(row1, col1a));
+ }
+
+ {
+ TextView v = new TextView(context);
+ v.setTextSize(20);
+ v.setText("You can configure email in just a few steps:");
+ vg.addView(v, new LayoutParams(row2, col1b));
+ }
+
+ {
+ TextView v = new TextView(context);
+ v.setText("Email address:");
+ vg.addView(v, new LayoutParams(row3, col1c));
+ }
+
+ {
+ EditText v = new EditText(context);
+ v.setInputType(TYPE_CLASS_TEXT | TYPE_TEXT_VARIATION_EMAIL_ADDRESS);
+ {
+ LayoutParams lp = new LayoutParams(row3, col2);
+ lp.width = (int) v.getPaint().measureText("Frederick.W.Flintstone@bedrock.com ");
+ vg.addView(v, lp);
+ }
+ }
+
+ {
+ TextView v = new TextView(context);
+ v.setText("Password:");
+ vg.addView(v, new LayoutParams(row4, col1c));
+ }
+
+ {
+ TextView v = new EditText(context);
+ v.setInputType(TYPE_CLASS_TEXT | TYPE_TEXT_VARIATION_PASSWORD);
+ {
+ LayoutParams lp = new LayoutParams(row4, col2);
+ lp.width = (int) v.getPaint().measureText("************");
+ vg.addView(v, lp);
+ }
+ }
+
+ {
+ Space v = new Space(context);
+ {
+ LayoutParams lp = new LayoutParams(row5, col3);
+ lp.rowWeight = 1;
+ lp.columnWeight = 1;
+ vg.addView(v, lp);
+ }
+ }
+
+ {
+ Button v = new Button(context);
+ v.setText("Manual setup");
+ vg.addView(v, new LayoutParams(row6, col4));
+ }
+
+ {
+ Button v = new Button(context);
+ v.setText("Next");
+ vg.addView(v, new LayoutParams(row7, col4));
+ }
+
+ return vg;
+ }
+
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(create(getBaseContext()));
+ }
+
+}
\ No newline at end of file
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity3.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity3.java
new file mode 100644
index 0000000..fc0b382
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity3.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity3 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid3);
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity4.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity4.java
new file mode 100644
index 0000000..444f87c
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity4.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 20101 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity4 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid4);
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity5.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity5.java
new file mode 100644
index 0000000..d317526
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity5.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity5 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid5);
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity6.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity6.java
new file mode 100644
index 0000000..9bc9f9f
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity6.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity6 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid6);
+ }
+}
diff --git a/tests/GridLayoutTest/src/com/android/test/layout/Activity7.java b/tests/GridLayoutTest/src/com/android/test/layout/Activity7.java
new file mode 100644
index 0000000..6350381
--- /dev/null
+++ b/tests/GridLayoutTest/src/com/android/test/layout/Activity7.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.test.layout;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+public class Activity7 extends Activity {
+ protected void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ setContentView(R.layout.grid7);
+ }
+}