* The grid is composed of a set of infinitely thin lines that separate the
* viewing area into cells. Throughout the API, grid lines are referenced
* by grid indices. A grid that has N columns
* has N + 1 grid indices that run from 0
* through N inclusive. Regardless of how GridLayout is
* configured, grid index 0 is fixed to the leading edge of the
* container and grid index N is fixed to its trailing edge
* (after padding is taken into account).
*
*
*
* 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. *
* 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 false, the default state, GridLayout
* is at liberty to choose an order that better suits the heights of its children.
* When this property is true, 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.
*
* GridLayout implements this specification by creating ordering constraints between
* the variables that represent the locations of the row boundaries.
*
* When this property is true, constraints are added for each pair of consecutive
* indices: i.e. between row boundaries: [0..1], [1..2], [3..4],... etc.
*
* When the property is false, 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 false, the default state, GridLayout
* is at liberty to choose an order that better suits the widths of its children.
* When this property is true, 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.
*
* GridLayout implements this specification by creating ordering constraints between
* the variables that represent the locations of the column boundaries.
*
* When this property is
* 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.
*
* 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.
*
* 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.
*
* See {@link GridLayout} for a description of the conventions used by GridLayout
* in reference to grid indices.
*
*
* 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.
*
* Intervals are often written as
* Groups are immutable and so may be shared between views with the same
*
* 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,
* 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.
*
* 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.
*
* 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 top
* edges of the other views in its cell group.
*/
public static final Alignment TOP = LEADING;
/**
* Indicates that a view should be aligned with the bottom
* edges of the other views in its cell group.
*/
public static final Alignment BOTTOM = TRAILING;
/**
* Indicates that a view should be aligned with the right
* edges of the other views in its cell group.
*/
public static final Alignment RIGHT = TRAILING;
/**
* Indicates that a view should be aligned with the left
* edges of the other views in its cell group.
*/
public static final Alignment LEFT = LEADING;
/**
* Indicates that a view should be centered 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 baselines
* 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;
}
};
}true, constraints are added for each pair of consecutive
* indices: i.e. between column boundaries: [0..1], [1..2], [3..4],... etc.
*
* When the property is false, 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;
PackedMapDefault values
*
*
*
*
* @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 false; otherwise {@link Integer#MIN_VALUE}, to
* indicate that a default value should be computed on demand. false; otherwise {@link Integer#MIN_VALUE}, to
* indicate that a default value should be computed on demand. false; otherwise {@link Integer#MIN_VALUE}, to
* indicate that a default value should be computed on demand. false; otherwise {@link Integer#MIN_VALUE}, to
* indicate that a default value should be computed on demand. .span = [0, 1] .alignment = {@link #BASELINE} .span = [0, 1] .alignment = {@link #LEFT} 0f 0f rowGroup
* and columnGroup. 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 LEFT | BASELINE.
*
* @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[min, max] and represent the set of values
* x such that min <= x < max.
*/
public static class Interval {
/**
* The minimum value.
*/
public final int min;
/**
* The maximum value.
*/
public final int max;
/**
* Construct a new Interval, interval, where:
*
*
*
* @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.
* interval.min = min interval.max = max span and alignment.
*/
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.
* group, where:
*
*
*
* @param span the span.
* @param alignment the alignment.
*/
public Group(Interval span, Alignment alignment) {
this.span = span;
this.alignment = alignment;
}
/**
* Construct a new Group, group.span = span group.alignment = alignment group, where:
*
*
*
* @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, group.span = [min, max] group.alignment = alignment group, where:
*
*
*
* @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.
* group.span = [min, min + 1] group.alignment = alignment