/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
*
* 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.ide.common.layout.grid;
import static com.android.SdkConstants.ANDROID_URI;
import static com.android.SdkConstants.ATTR_COLUMN_COUNT;
import static com.android.SdkConstants.ATTR_ID;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN;
import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN_SPAN;
import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY;
import static com.android.SdkConstants.ATTR_LAYOUT_HEIGHT;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW;
import static com.android.SdkConstants.ATTR_LAYOUT_ROW_SPAN;
import static com.android.SdkConstants.ATTR_LAYOUT_WIDTH;
import static com.android.SdkConstants.ATTR_ORIENTATION;
import static com.android.SdkConstants.ATTR_ROW_COUNT;
import static com.android.SdkConstants.FQCN_GRID_LAYOUT;
import static com.android.SdkConstants.FQCN_SPACE;
import static com.android.SdkConstants.FQCN_SPACE_V7;
import static com.android.SdkConstants.GRID_LAYOUT;
import static com.android.SdkConstants.NEW_ID_PREFIX;
import static com.android.SdkConstants.SPACE;
import static com.android.SdkConstants.VALUE_BOTTOM;
import static com.android.SdkConstants.VALUE_CENTER_VERTICAL;
import static com.android.SdkConstants.VALUE_N_DP;
import static com.android.SdkConstants.VALUE_TOP;
import static com.android.SdkConstants.VALUE_VERTICAL;
import static com.android.ide.common.layout.GravityHelper.GRAVITY_BOTTOM;
import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_HORIZ;
import static com.android.ide.common.layout.GravityHelper.GRAVITY_CENTER_VERT;
import static com.android.ide.common.layout.GravityHelper.GRAVITY_RIGHT;
import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.Math.min;
import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.api.IClientRulesEngine;
import com.android.ide.common.api.INode;
import com.android.ide.common.api.IViewMetadata;
import com.android.ide.common.api.Margins;
import com.android.ide.common.api.Rect;
import com.android.ide.common.layout.GravityHelper;
import com.android.ide.common.layout.GridLayoutRule;
import com.android.utils.Pair;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.Multimap;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.ref.WeakReference;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/** Models a GridLayout */
public class GridModel {
/** Marker value used to indicate values (rows, columns, etc) which have not been set */
static final int UNDEFINED = Integer.MIN_VALUE;
/** The size of spacers in the dimension that they are not defining */
private static final int SPACER_SIZE_DP = 1;
/** Attribute value used for {@link #SPACER_SIZE_DP} */
private static final String SPACER_SIZE = String.format(VALUE_N_DP, SPACER_SIZE_DP);
/** Width assigned to a newly added column with the Add Column action */
private static final int DEFAULT_CELL_WIDTH = 100;
/** Height assigned to a newly added row with the Add Row action */
private static final int DEFAULT_CELL_HEIGHT = 15;
/** The GridLayout node, never null */
public final INode layout;
/** True if this is a vertical layout, and false if it is horizontal (the default) */
public boolean vertical;
/** The declared count of rows (which may be {@link #UNDEFINED} if not specified) */
public int declaredRowCount;
/** The declared count of columns (which may be {@link #UNDEFINED} if not specified) */
public int declaredColumnCount;
/** The actual count of rows found in the grid */
public int actualRowCount;
/** The actual count of columns found in the grid */
public int actualColumnCount;
/**
* Array of positions (indexed by column) of the left edge of table cells; this
* corresponds to the column positions in the grid
*/
private int[] mLeft;
/**
* Array of positions (indexed by row) of the top edge of table cells; this
* corresponds to the row positions in the grid
*/
private int[] mTop;
/**
* Array of positions (indexed by column) of the maximum right hand side bounds of a
* node in the given column; this represents the visual edge of a column even when the
* actual column is wider
*/
private int[] mMaxRight;
/**
* Array of positions (indexed by row) of the maximum bottom bounds of a node in the
* given row; this represents the visual edge of a row even when the actual row is
* taller
*/
private int[] mMaxBottom;
/**
* Array of baselines computed for the rows. This array is populated lazily and should
* not be accessed directly; call {@link #getBaseline(int)} instead.
*/
private int[] mBaselines;
/** List of all the view data for the children in this layout */
private List<ViewData> mChildViews;
/** The {@link IClientRulesEngine} */
private final IClientRulesEngine mRulesEngine;
/**
* An actual instance of a GridLayout object that this grid model corresponds to.
*/
private Object mViewObject;
/** The namespace to use for attributes */
private String mNamespace;
/**
* Constructs a {@link GridModel} for the given layout
*
* @param rulesEngine the associated rules engine
* @param node the GridLayout node
* @param viewObject an actual GridLayout instance, or null
*/
private GridModel(IClientRulesEngine rulesEngine, INode node, Object viewObject) {
mRulesEngine = rulesEngine;
layout = node;
mViewObject = viewObject;
loadFromXml();
}
// Factory cache for most recent item (used primarily because during paints and drags
// the grid model is called repeatedly for the same view object.)
private static WeakReference<Object> sCachedViewObject = new WeakReference<Object>(null);
private static WeakReference<GridModel> sCachedViewModel;
/**
* Factory which returns a grid model for the given node.
*
* @param rulesEngine the associated rules engine
* @param node the GridLayout node
* @param viewObject an actual GridLayout instance, or null
* @return a new model
*/
@NonNull
public static GridModel get(
@NonNull IClientRulesEngine rulesEngine,
@NonNull INode node,
@Nullable Object viewObject) {
if (viewObject != null && viewObject == sCachedViewObject.get()) {
GridModel model = sCachedViewModel.get();
if (model != null) {
return model;
}
}
GridModel model = new GridModel(rulesEngine, node, viewObject);
sCachedViewModel = new WeakReference<GridModel>(model);
sCachedViewObject = new WeakReference<Object>(viewObject);
return model;
}
/**
* Returns the {@link ViewData} for the child at the given index
*
* @param index the position of the child node whose view we want to look up
* @return the corresponding {@link ViewData}
*/
public ViewData getView(int index) {
return mChildViews.get(index);
}
/**
* Returns the {@link ViewData} for the given child node.
*
* @param node the node for which we want the view info
* @return the view info for the node, or null if not found
*/
public ViewData getView(INode node) {
for (ViewData view : mChildViews) {
if (view.node == node) {
return view;
}
}
return null;
}
/**
* Computes the index (among the children nodes) to insert a new node into which
* should be positioned at the given row and column. This will skip over any nodes
* that have implicit positions earlier than the given node, and will also ensure that
* all nodes are placed before the spacer nodes.
*
* @param row the target row of the new node
* @param column the target column of the new node
* @return the insert position to use or -1 if no preference is found
*/
public int getInsertIndex(int row, int column) {
if (vertical) {
for (ViewData view : mChildViews) {
if (view.column > column || view.column == column && view.row >= row) {
return view.index;
}
}
} else {
for (ViewData view : mChildViews) {
if (view.row > row || view.row == row && view.column >= column) {
return view.index;
}
}
}
// Place it before the first spacer
for (ViewData view : mChildViews) {
if (view.isSpacer()) {
return view.index;
}
}
return -1;
}
/**
* Returns the baseline of the given row, or -1 if none is found. This looks for views
* in the row which have baseline vertical alignment and also define their own
* baseline, and returns the first such match.
*
* @param row the row to look up a baseline for
* @return the baseline relative to the row position, or -1 if not defined
*/
public int getBaseline(int row) {
if (row < 0 || row >= mBaselines.length) {
return -1;
}
int baseline = mBaselines[row];
if (baseline == UNDEFINED) {
baseline = -1;
// TBD: Consider stringing together row information in the view data
// so I can quickly identify the views in a given row instead of searching
// among all?
for (ViewData view : mChildViews) {
// We only count baselines for views with rowSpan=1 because
// baseline alignment doesn't work for cell spanning views
if (view.row == row && view.rowSpan == 1) {
baseline = view.node.getBaseline();
if (baseline != -1) {
// Even views that do have baselines do not count towards a row
// baseline if they have a vertical gravity
String gravity = getGridAttribute(view.node, ATTR_LAYOUT_GRAVITY);
if (gravity == null
|| !(gravity.contains(VALUE_TOP)
|| gravity.contains(VALUE_BOTTOM)
|| gravity.contains(VALUE_CENTER_VERTICAL))) {
// Compute baseline relative to the row, not the view itself
baseline += view.node.getBounds().y - getRowY(row);
break;
}
}
}
}
mBaselines[row] = baseline;
}
return baseline;
}
/** Applies the row and column values into the XML */
void applyPositionAttributes() {
for (ViewData view : mChildViews) {
view.applyPositionAttributes();
}
// Also fix the columnCount
if (getGridAttribute(layout, ATTR_COLUMN_COUNT) != null &&
declaredColumnCount > actualColumnCount) {
setGridAttribute(layout, ATTR_COLUMN_COUNT, actualColumnCount);
}
}
/**
* Sets the given GridLayout attribute (rowCount, layout_row, etc) to the
* given value. This automatically handles using the right XML namespace
* based on whether the GridLayout is the android.widget.GridLayout, or the
* support library GridLayout, and whether it's in a library project or not
* etc.
*
* @param node the node to apply the attribute to
* @param name the local name of the attribute
* @param value the integer value to set the attribute to
*/
public void setGridAttribute(INode node, String name, int value) {
setGridAttribute(node, name, Integer.toString(value));
}
/**
* Sets the given GridLayout attribute (rowCount, layout_row, etc) to the
* given value. This automatically handles using the right XML namespace
* based on whether the GridLayout is the android.widget.GridLayout, or the
* support library GridLayout, and whether it's in a library project or not
* etc.
*
* @param node the node to apply the attribute to
* @param name the local name of the attribute
* @param value the string value to set the attribute to, or null to clear
* it
*/
public void setGridAttribute(INode node, String name, String value) {
node.setAttribute(getNamespace(), name, value);
}
/**
* Returns the namespace URI to use for GridLayout-specific attributes, such
* as columnCount, layout_column, layout_column_span, layout_gravity etc.
*
* @return the namespace, never null
*/
public String getNamespace() {
if (mNamespace == null) {
mNamespace = ANDROID_URI;
if (!layout.getFqcn().equals(FQCN_GRID_LAYOUT)) {
mNamespace = mRulesEngine.getAppNameSpace();
}
}
return mNamespace;
}
/** Removes the given flag from a flag attribute value and returns the result */
static String removeFlag(String flag, String value) {
if (value.equals(flag)) {
return null;
}
// Handle spaces between pipes and flag are a prefix, suffix and interior occurrences
int index = value.indexOf(flag);
if (index != -1) {
int pipe = value.lastIndexOf('|', index);
int endIndex = index + flag.length();
if (pipe != -1) {
value = value.substring(0, pipe).trim() + value.substring(endIndex).trim();
} else {
pipe = value.indexOf('|', endIndex);
if (pipe != -1) {
value = value.substring(0, index).trim() + value.substring(pipe + 1).trim();
} else {
value = value.substring(0, index).trim() + value.substring(endIndex).trim();
}
}
}
return value;
}
/**
* Loads a {@link GridModel} from the XML model.
*/
private void loadFromXml() {
INode[] children = layout.getChildren();
declaredRowCount = getGridAttribute(layout, ATTR_ROW_COUNT, UNDEFINED);
declaredColumnCount = getGridAttribute(layout, ATTR_COLUMN_COUNT, UNDEFINED);
// Horizontal is the default, so if no value is specified it is horizontal.
vertical = VALUE_VERTICAL.equals(getGridAttribute(layout, ATTR_ORIENTATION));
mChildViews = new ArrayList<ViewData>(children.length);
int index = 0;
for (INode child : children) {
ViewData view = new ViewData(child, index++);
mChildViews.add(view);
}
// Assign row/column positions to all cells that do not explicitly define them
if (!assignRowsAndColumnsFromViews(mChildViews)) {
assignRowsAndColumnsFromXml(
declaredRowCount == UNDEFINED ? children.length : declaredRowCount,
declaredColumnCount == UNDEFINED ? children.length : declaredColumnCount);
}
assignCellBounds();
for (int i = 0; i <= actualRowCount; i++) {
mBaselines[i] = UNDEFINED;
}
}
private Pair<Map<Integer, Integer>, Map<Integer, Integer>> findCellsOutsideDeclaredBounds() {
// See if we have any (row,column) pairs that fall outside the declared
// bounds; for these we identify the number of unique values and assign these
// consecutive values
Map<Integer, Integer> extraColumnsMap = null;
Map<Integer, Integer> extraRowsMap = null;
if (declaredRowCount != UNDEFINED) {
Set<Integer> extraRows = null;
for (ViewData view : mChildViews) {
if (view.row >= declaredRowCount) {
if (extraRows == null) {
extraRows = new HashSet<Integer>();
}
extraRows.add(view.row);
}
}
if (extraRows != null && declaredRowCount != UNDEFINED) {
List<Integer> rows = new ArrayList<Integer>(extraRows);
Collections.sort(rows);
int row = declaredRowCount;
extraRowsMap = new HashMap<Integer, Integer>();
for (Integer declared : rows) {
extraRowsMap.put(declared, row++);
}
}
}
if (declaredColumnCount != UNDEFINED) {
Set<Integer> extraColumns = null;
for (ViewData view : mChildViews) {
if (view.column >= declaredColumnCount) {
if (extraColumns == null) {
extraColumns = new HashSet<Integer>();
}
extraColumns.add(view.column);
}
}
if (extraColumns != null && declaredColumnCount != UNDEFINED) {
List<Integer> columns = new ArrayList<Integer>(extraColumns);
Collections.sort(columns);
int column = declaredColumnCount;
extraColumnsMap = new HashMap<Integer, Integer>();
for (Integer declared : columns) {
extraColumnsMap.put(declared, column++);
}
}
}
return Pair.of(extraRowsMap, extraColumnsMap);
}
/**
* Figure out actual row and column numbers for views that do not specify explicit row
* and/or column numbers
* TODO: Consolidate with the algorithm in GridLayout to ensure we get the
* exact same results!
*/
private void assignRowsAndColumnsFromXml(int rowCount, int columnCount) {
Pair<Map<Integer, Integer>, Map<Integer, Integer>> p = findCellsOutsideDeclaredBounds();
Map<Integer, Integer> extraRowsMap = p.getFirst();
Map<Integer, Integer> extraColumnsMap = p.getSecond();
if (!vertical) {
// Horizontal GridLayout: this is the default. Row and column numbers
// are assigned by assuming that the children are assigned successive
// column numbers until we get to the column count of the grid, at which
// point we jump to the next row. If any cell specifies either an explicit
// row number of column number, we jump to the next available position.
// Note also that if there are any rowspans on the current row, then the
// next row we jump to is below the largest such rowspan - in other words,
// the algorithm does not fill holes in the middle!
// TODO: Ensure that we don't run into trouble if a later element specifies
// an earlier number... find out what the layout does in that case!
int row = 0;
int column = 0;
int nextRow = 1;
for (ViewData view : mChildViews) {
int declaredColumn = view.column;
if (declaredColumn != UNDEFINED) {
if (declaredColumn >= columnCount) {
assert extraColumnsMap != null;
declaredColumn = extraColumnsMap.get(declaredColumn);
view.column = declaredColumn;
}
if (declaredColumn < column) {
// Must jump to the next row to accommodate the new row
assert nextRow > row;
//row++;
row = nextRow;
}
column = declaredColumn;
} else {
view.column = column;
}
if (view.row != UNDEFINED) {
// TODO: Should this adjust the column number too? (If so must
// also update view.column since we've already processed the local
// column number)
row = view.row;
} else {
view.row = row;
}
nextRow = Math.max(nextRow, view.row + view.rowSpan);
// Advance
column += view.columnSpan;
if (column >= columnCount) {
column = 0;
assert nextRow > row;
//row++;
row = nextRow;
}
}
} else {
// Vertical layout: successive children are assigned to the same column in
// successive rows.
int row = 0;
int column = 0;
int nextColumn = 1;
for (ViewData view : mChildViews) {
int declaredRow = view.row;
if (declaredRow != UNDEFINED) {
if (declaredRow >= rowCount) {
declaredRow = extraRowsMap.get(declaredRow);
view.row = declaredRow;
}
if (declaredRow < row) {
// Must jump to the next column to accommodate the new column
assert nextColumn > column;
column = nextColumn;
}
row = declaredRow;
} else {
view.row = row;
}
if (view.column != UNDEFINED) {
// TODO: Should this adjust the row number too? (If so must
// also update view.row since we've already processed the local
// row number)
column = view.column;
} else {
view.column = column;
}
nextColumn = Math.max(nextColumn, view.column + view.columnSpan);
// Advance
row += view.rowSpan;
if (row >= rowCount) {
row = 0;
assert nextColumn > column;
//row++;
column = nextColumn;
}
}
}
}
private static boolean sAttemptSpecReflection = true;
private boolean assignRowsAndColumnsFromViews(List<ViewData> views) {
if (!sAttemptSpecReflection) {
return false;
}
try {
// Lazily initialized reflection methods
Field spanField = null;
Field rowSpecField = null;
Field colSpecField = null;
Field minField = null;
Field maxField = null;
Method getLayoutParams = null;
for (ViewData view : views) {
// TODO: If the element *specifies* anything in XML, use that instead
Object child = mRulesEngine.getViewObject(view.node);
if (child == null) {
// Fallback to XML model
return false;
}
if (getLayoutParams == null) {
getLayoutParams = child.getClass().getMethod("getLayoutParams"); //$NON-NLS-1$
}
Object layoutParams = getLayoutParams.invoke(child);
if (rowSpecField == null) {
Class<? extends Object> layoutParamsClass = layoutParams.getClass();
rowSpecField = layoutParamsClass.getDeclaredField("rowSpec"); //$NON-NLS-1$
colSpecField = layoutParamsClass.getDeclaredField("columnSpec"); //$NON-NLS-1$
rowSpecField.setAccessible(true);
colSpecField.setAccessible(true);
}
assert colSpecField != null;
Object rowSpec = rowSpecField.get(layoutParams);
Object colSpec = colSpecField.get(layoutParams);
if (spanField == null) {
spanField = rowSpec.getClass().getDeclaredField("span"); //$NON-NLS-1$
spanField.setAccessible(true);
}
assert spanField != null;
Object rowInterval = spanField.get(rowSpec);
Object colInterval = spanField.get(colSpec);
if (minField == null) {
Class<? extends Object> intervalClass = rowInterval.getClass();
minField = intervalClass.getDeclaredField("min"); //$NON-NLS-1$
maxField = intervalClass.getDeclaredField("max"); //$NON-NLS-1$
minField.setAccessible(true);
maxField.setAccessible(true);
}
assert maxField != null;
int row = minField.getInt(rowInterval);
int col = minField.getInt(colInterval);
int rowEnd = maxField.getInt(rowInterval);
int colEnd = maxField.getInt(colInterval);
view.column = col;
view.row = row;
view.columnSpan = colEnd - col;
view.rowSpan = rowEnd - row;
}
return true;
} catch (Throwable e) {
sAttemptSpecReflection = false;
return false;
}
}
/**
* Computes the positions of the column and row boundaries
*/
private void assignCellBounds() {
if (!assignCellBoundsFromView()) {
assignCellBoundsFromBounds();
}
initializeMaxBounds();
mBaselines = new int[actualRowCount + 1];
}
/**
* Computes the positions of the column and row boundaries, using actual
* layout data from the associated GridLayout instance (stored in
* {@link #mViewObject})
*/
private boolean assignCellBoundsFromView() {
if (mViewObject != null) {
Pair<int[], int[]> cellBounds = GridModel.getAxisBounds(mViewObject);
if (cellBounds != null) {
int[] xs = cellBounds.getFirst();
int[] ys = cellBounds.getSecond();
actualColumnCount = xs.length - 1;
actualRowCount = ys.length - 1;
Rect layoutBounds = layout.getBounds();
int layoutBoundsX = layoutBounds.x;
int layoutBoundsY = layoutBounds.y;
mLeft = new int[xs.length];
mTop = new int[ys.length];
for (int i = 0; i < xs.length; i++) {
mLeft[i] = xs[i] + layoutBoundsX;
}
for (int i = 0; i < ys.length; i++) {
mTop[i] = ys[i] + layoutBoundsY;
}
return true;
}
}
return false;
}
/**
* Computes the boundaries of the rows and columns by considering the bounds of the
* children.
*/
private void assignCellBoundsFromBounds() {
Rect layoutBounds = layout.getBounds();
// Compute the actualColumnCount and actualRowCount. This -should- be
// as easy as declaredColumnCount + extraColumnsMap.size(),
// but the user doesn't *have* to declare a column count (or a row count)
// and we need both, so go and find the actual row and column maximums.
int maxColumn = 0;
int maxRow = 0;
for (ViewData view : mChildViews) {
maxColumn = max(maxColumn, view.column);
maxRow = max(maxRow, view.row);
}
actualColumnCount = maxColumn + 1;
actualRowCount = maxRow + 1;
mLeft = new int[actualColumnCount + 1];
for (int i = 1; i < actualColumnCount; i++) {
mLeft[i] = UNDEFINED;
}
mLeft[0] = layoutBounds.x;
mLeft[actualColumnCount] = layoutBounds.x2();
mTop = new int[actualRowCount + 1];
for (int i = 1; i < actualRowCount; i++) {
mTop[i] = UNDEFINED;
}
mTop[0] = layoutBounds.y;
mTop[actualRowCount] = layoutBounds.y2();
for (ViewData view : mChildViews) {
Rect bounds = view.node.getBounds();
if (!bounds.isValid()) {
continue;
}
int column = view.column;
int row = view.row;
if (mLeft[column] == UNDEFINED) {
mLeft[column] = bounds.x;
} else {
mLeft[column] = Math.min(bounds.x, mLeft[column]);
}
if (mTop[row] == UNDEFINED) {
mTop[row] = bounds.y;
} else {
mTop[row] = Math.min(bounds.y, mTop[row]);
}
}
// Ensure that any empty columns/rows have a valid boundary value; for now,
for (int i = actualColumnCount - 1; i >= 0; i--) {
if (mLeft[i] == UNDEFINED) {
if (i == 0) {
mLeft[i] = layoutBounds.x;
} else if (i < actualColumnCount - 1) {
mLeft[i] = mLeft[i + 1] - 1;
if (mLeft[i - 1] != UNDEFINED && mLeft[i] < mLeft[i - 1]) {
mLeft[i] = mLeft[i - 1];
}
} else {
mLeft[i] = layoutBounds.x2();
}
}
}
for (int i = actualRowCount - 1; i >= 0; i--) {
if (mTop[i] == UNDEFINED) {
if (i == 0) {
mTop[i] = layoutBounds.y;
} else if (i < actualRowCount - 1) {
mTop[i] = mTop[i + 1] - 1;
if (mTop[i - 1] != UNDEFINED && mTop[i] < mTop[i - 1]) {
mTop[i] = mTop[i - 1];
}
} else {
mTop[i] = layoutBounds.y2();
}
}
}
// The bounds should be in ascending order now
if (false && GridLayoutRule.sDebugGridLayout) {
for (int i = 1; i < actualRowCount; i++) {
assert mTop[i + 1] >= mTop[i];
}
for (int i = 0; i < actualColumnCount; i++) {
assert mLeft[i + 1] >= mLeft[i];
}
}
}
/**
* Determine, for each row and column, what the largest x and y edges are
* within that row or column. This is used to find a natural split point to
* suggest when adding something "to the right of" or "below" another view.
*/
private void initializeMaxBounds() {
mMaxRight = new int[actualColumnCount + 1];
mMaxBottom = new int[actualRowCount + 1];
for (ViewData view : mChildViews) {
Rect bounds = view.node.getBounds();
if (!bounds.isValid()) {
continue;
}
if (!view.isSpacer()) {
int x2 = bounds.x2();
int y2 = bounds.y2();
int column = view.column;
int row = view.row;
int targetColumn = min(actualColumnCount - 1,
column + view.columnSpan - 1);
int targetRow = min(actualRowCount - 1, row + view.rowSpan - 1);
IViewMetadata metadata = mRulesEngine.getMetadata(view.node.getFqcn());
if (metadata != null) {
Margins insets = metadata.getInsets();
if (insets != null) {
x2 -= insets.right;
y2 -= insets.bottom;
}
}
if (mMaxRight[targetColumn] < x2
&& ((view.gravity & (GRAVITY_CENTER_HORIZ | GRAVITY_RIGHT)) == 0)) {
mMaxRight[targetColumn] = x2;
}
if (mMaxBottom[targetRow] < y2
&& ((view.gravity & (GRAVITY_CENTER_VERT | GRAVITY_BOTTOM)) == 0)) {
mMaxBottom[targetRow] = y2;
}
}
}
}
/**
* Looks up the x[] and y[] locations of the columns and rows in the given GridLayout
* instance.
*
* @param view the GridLayout object, which should already have performed layout
* @return a pair of x[] and y[] integer arrays, or null if it could not be found
*/
public static Pair<int[], int[]> getAxisBounds(Object view) {
try {
Class<?> clz = view.getClass();
Field horizontalAxis = clz.getDeclaredField("horizontalAxis"); //$NON-NLS-1$
Field verticalAxis = clz.getDeclaredField("verticalAxis"); //$NON-NLS-1$
horizontalAxis.setAccessible(true);
verticalAxis.setAccessible(true);
Object horizontal = horizontalAxis.get(view);
Object vertical = verticalAxis.get(view);
Field locations = horizontal.getClass().getDeclaredField("locations"); //$NON-NLS-1$
assert locations.getType().isArray() : locations.getType();
locations.setAccessible(true);
Object horizontalLocations = locations.get(horizontal);
Object verticalLocations = locations.get(vertical);
int[] xs = (int[]) horizontalLocations;
int[] ys = (int[]) verticalLocations;
return Pair.of(xs, ys);
} catch (Throwable t) {
// Probably trying to show a GridLayout on a platform that does not support it.
// Return null to indicate that the grid bounds must be computed from view bounds.
return null;
}
}
/**
* Add a new column.
*
* @param selectedChildren if null or empty, add the column at the end of the grid,
* and otherwise add it before the column of the first selected child
* @return the newly added column spacer
*/
public INode addColumn(List<? extends INode> selectedChildren) {
// Determine insert index
int newColumn = actualColumnCount;
if (selectedChildren != null && selectedChildren.size() > 0) {
INode first = selectedChildren.get(0);
ViewData view = getView(first);
newColumn = view.column;
}
INode newView = addColumn(newColumn, null, UNDEFINED, false, UNDEFINED, UNDEFINED);
if (newView != null) {
mRulesEngine.select(Collections.singletonList(newView));
}
return newView;
}
/**
* Adds a new column.
*
* @param newColumn the column index to insert before
* @param newView the {@link INode} to insert as the column spacer, which may be null
* (in which case a spacer is automatically created)
* @param columnWidthDp the width, in device independent pixels, of the column to be
* added (which may be {@link #UNDEFINED}
* @param split if true, split the existing column into two at the given x position
* @param row the row to add the newView to
* @param x the x position of the column we're inserting
* @return the column spacer
*/
public INode addColumn(int newColumn, INode newView, int columnWidthDp,
boolean split, int row, int x) {
// Insert a new column
actualColumnCount++;
if (declaredColumnCount != UNDEFINED) {
declaredColumnCount++;
setGridAttribute(layout, ATTR_COLUMN_COUNT, declaredColumnCount);
}
boolean isLastColumn = true;
for (ViewData view : mChildViews) {
if (view.column >= newColumn) {
isLastColumn = false;
break;
}
}
for (ViewData view : mChildViews) {
boolean columnSpanSet = false;
int endColumn = view.column + view.columnSpan;
if (view.column >= newColumn || endColumn == newColumn) {
if (view.column == newColumn || endColumn == newColumn) {
//if (view.row == 0) {
if (newView == null && !isLastColumn) {
// Insert a new spacer
int index = getChildIndex(layout.getChildren(), view.node);
assert view.index == index; // TODO: Get rid of getter
if (endColumn == newColumn) {
// This cell -ends- at the desired position: insert it after
index++;
}
ViewData newViewData = addSpacer(layout, index,
split ? row : UNDEFINED,
split ? newColumn - 1 : UNDEFINED,
columnWidthDp != UNDEFINED ? columnWidthDp : DEFAULT_CELL_WIDTH,
DEFAULT_CELL_HEIGHT);
newViewData.column = newColumn - 1;
newViewData.row = row;
newView = newViewData.node;
}
// Set the actual row number on the first cell on the new row.
// This means we don't really need the spacer above to imply
// the new row number, but we use the spacer to assign the row
// some height.
if (view.column == newColumn) {
view.column++;
setGridAttribute(view.node, ATTR_LAYOUT_COLUMN, view.column);
} // else: endColumn == newColumn: handled below
} else if (getGridAttribute(view.node, ATTR_LAYOUT_COLUMN) != null) {
view.column++;
setGridAttribute(view.node, ATTR_LAYOUT_COLUMN, view.column);
}
} else if (endColumn > newColumn) {
view.columnSpan++;
setColumnSpanAttribute(view.node, view.columnSpan);
columnSpanSet = true;
}
if (split && !columnSpanSet && view.node.getBounds().x2() > x) {
if (view.node.getBounds().x < x) {
view.columnSpan++;
setColumnSpanAttribute(view.node, view.columnSpan);
}
}
}
// Hardcode the row numbers if the last column is a new column such that
// they don't jump back to backfill the previous row's new last cell
if (isLastColumn) {
for (ViewData view : mChildViews) {
if (view.column == 0 && view.row > 0) {
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
}
}
if (split) {
assert newView == null;
addSpacer(layout, -1, row, newColumn -1,
columnWidthDp != UNDEFINED ? columnWidthDp : DEFAULT_CELL_WIDTH,
SPACER_SIZE_DP);
}
}
return newView;
}
/**
* Removes the columns containing the given selection
*
* @param selectedChildren a list of nodes whose columns should be deleted
*/
public void removeColumns(List<? extends INode> selectedChildren) {
if (selectedChildren.size() == 0) {
return;
}
// Figure out which columns should be removed
Set<Integer> removeColumns = new HashSet<Integer>();
Set<ViewData> removedViews = new HashSet<ViewData>();
for (INode child : selectedChildren) {
ViewData view = getView(child);
removedViews.add(view);
removeColumns.add(view.column);
}
// Sort them in descending order such that we can process each
// deletion independently
List<Integer> removed = new ArrayList<Integer>(removeColumns);
Collections.sort(removed, Collections.reverseOrder());
for (int removedColumn : removed) {
// Remove column.
// First, adjust column count.
// TODO: Don't do this if the column being deleted is outside
// the declared column range!
// TODO: Do this under a write lock? / editXml lock?
actualColumnCount--;
if (declaredColumnCount != UNDEFINED) {
declaredColumnCount--;
}
// Remove any elements that begin in the deleted columns...
// If they have colspan > 1, then we must insert a spacer instead.
// For any other elements that overlap, we need to subtract from the span.
for (ViewData view : mChildViews) {
if (view.column == removedColumn) {
int index = getChildIndex(layout.getChildren(), view.node);
assert view.index == index; // TODO: Get rid of getter
if (view.columnSpan > 1) {
// Make a new spacer which is the width of the following
// columns
int columnWidth = getColumnWidth(removedColumn, view.columnSpan) -
getColumnWidth(removedColumn, 1);
int columnWidthDip = mRulesEngine.pxToDp(columnWidth);
ViewData spacer = addSpacer(layout, index, UNDEFINED, UNDEFINED,
columnWidthDip, SPACER_SIZE_DP);
spacer.row = 0;
spacer.column = removedColumn;
}
layout.removeChild(view.node);
} else if (view.column < removedColumn
&& view.column + view.columnSpan > removedColumn) {
// Subtract column span to skip this item
view.columnSpan--;
setColumnSpanAttribute(view.node, view.columnSpan);
} else if (view.column > removedColumn) {
view.column--;
if (getGridAttribute(view.node, ATTR_LAYOUT_COLUMN) != null) {
setGridAttribute(view.node, ATTR_LAYOUT_COLUMN, view.column);
}
}
}
}
// Remove children from child list!
if (removedViews.size() <= 2) {
mChildViews.removeAll(removedViews);
} else {
List<ViewData> remaining =
new ArrayList<ViewData>(mChildViews.size() - removedViews.size());
for (ViewData view : mChildViews) {
if (!removedViews.contains(view)) {
remaining.add(view);
}
}
mChildViews = remaining;
}
//if (declaredColumnCount != UNDEFINED) {
setGridAttribute(layout, ATTR_COLUMN_COUNT, actualColumnCount);
//}
}
/**
* Add a new row.
*
* @param selectedChildren if null or empty, add the row at the bottom of the grid,
* and otherwise add it before the row of the first selected child
* @return the newly added row spacer
*/
public INode addRow(List<? extends INode> selectedChildren) {
// Determine insert index
int newRow = actualRowCount;
if (selectedChildren.size() > 0) {
INode first = selectedChildren.get(0);
ViewData view = getView(first);
newRow = view.row;
}
INode newView = addRow(newRow, null, UNDEFINED, false, UNDEFINED, UNDEFINED);
if (newView != null) {
mRulesEngine.select(Collections.singletonList(newView));
}
return newView;
}
/**
* Adds a new column.
*
* @param newRow the row index to insert before
* @param newView the {@link INode} to insert as the row spacer, which may be null (in
* which case a spacer is automatically created)
* @param rowHeightDp the height, in device independent pixels, of the row to be added
* (which may be {@link #UNDEFINED}
* @param split if true, split the existing row into two at the given y position
* @param column the column to add the newView to
* @param y the y position of the row we're inserting
* @return the row spacer
*/
public INode addRow(int newRow, INode newView, int rowHeightDp, boolean split,
int column, int y) {
actualRowCount++;
if (declaredRowCount != UNDEFINED) {
declaredRowCount++;
setGridAttribute(layout, ATTR_ROW_COUNT, declaredRowCount);
}
boolean added = false;
for (ViewData view : mChildViews) {
if (view.row >= newRow) {
// Adjust the column count
if (view.row == newRow && view.column == 0) {
// Insert a new spacer
if (newView == null) {
int index = getChildIndex(layout.getChildren(), view.node);
assert view.index == index; // TODO: Get rid of getter
if (declaredColumnCount != UNDEFINED && !split) {
setGridAttribute(layout, ATTR_COLUMN_COUNT, declaredColumnCount);
}
ViewData newViewData = addSpacer(layout, index,
split ? newRow - 1 : UNDEFINED,
split ? column : UNDEFINED,
SPACER_SIZE_DP,
rowHeightDp != UNDEFINED ? rowHeightDp : DEFAULT_CELL_HEIGHT);
newViewData.column = column;
newViewData.row = newRow - 1;
newView = newViewData.node;
}
// Set the actual row number on the first cell on the new row.
// This means we don't really need the spacer above to imply
// the new row number, but we use the spacer to assign the row
// some height.
view.row++;
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
added = true;
} else if (getGridAttribute(view.node, ATTR_LAYOUT_ROW) != null) {
view.row++;
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
}
} else {
int endRow = view.row + view.rowSpan;
if (endRow > newRow) {
view.rowSpan++;
setRowSpanAttribute(view.node, view.rowSpan);
} else if (split && view.node.getBounds().y2() > y) {
if (view.node.getBounds().y < y) {
view.rowSpan++;
setRowSpanAttribute(view.node, view.rowSpan);
}
}
}
}
if (!added) {
// Append a row at the end
if (newView == null) {
ViewData newViewData = addSpacer(layout, -1, UNDEFINED, UNDEFINED,
SPACER_SIZE_DP,
rowHeightDp != UNDEFINED ? rowHeightDp : DEFAULT_CELL_HEIGHT);
newViewData.column = column;
// TODO: MAke sure this row number is right!
newViewData.row = split ? newRow - 1 : newRow;
newView = newViewData.node;
}
if (declaredColumnCount != UNDEFINED && !split) {
setGridAttribute(layout, ATTR_COLUMN_COUNT, declaredColumnCount);
}
if (split) {
setGridAttribute(newView, ATTR_LAYOUT_ROW, newRow - 1);
setGridAttribute(newView, ATTR_LAYOUT_COLUMN, column);
}
}
return newView;
}
/**
* Removes the rows containing the given selection
*
* @param selectedChildren a list of nodes whose rows should be deleted
*/
public void removeRows(List<? extends INode> selectedChildren) {
if (selectedChildren.size() == 0) {
return;
}
// Figure out which rows should be removed
Set<ViewData> removedViews = new HashSet<ViewData>();
Set<Integer> removedRows = new HashSet<Integer>();
for (INode child : selectedChildren) {
ViewData view = getView(child);
removedViews.add(view);
removedRows.add(view.row);
}
// Sort them in descending order such that we can process each
// deletion independently
List<Integer> removed = new ArrayList<Integer>(removedRows);
Collections.sort(removed, Collections.reverseOrder());
for (int removedRow : removed) {
// Remove row.
// First, adjust row count.
// TODO: Don't do this if the row being deleted is outside
// the declared row range!
actualRowCount--;
if (declaredRowCount != UNDEFINED) {
declaredRowCount--;
setGridAttribute(layout, ATTR_ROW_COUNT, declaredRowCount);
}
// Remove any elements that begin in the deleted rows...
// If they have colspan > 1, then we must hardcode a new row number
// instead.
// For any other elements that overlap, we need to subtract from the span.
for (ViewData view : mChildViews) {
if (view.row == removedRow) {
// We don't have to worry about a rowSpan > 1 here, because even
// if it is, those rowspans are not used to assign default row/column
// positions for other cells
// TODO: Check this; it differs from the removeColumns logic!
layout.removeChild(view.node);
} else if (view.row > removedRow) {
view.row--;
if (getGridAttribute(view.node, ATTR_LAYOUT_ROW) != null) {
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
}
} else if (view.row < removedRow
&& view.row + view.rowSpan > removedRow) {
// Subtract row span to skip this item
view.rowSpan--;
setRowSpanAttribute(view.node, view.rowSpan);
}
}
}
// Remove children from child list!
if (removedViews.size() <= 2) {
mChildViews.removeAll(removedViews);
} else {
List<ViewData> remaining =
new ArrayList<ViewData>(mChildViews.size() - removedViews.size());
for (ViewData view : mChildViews) {
if (!removedViews.contains(view)) {
remaining.add(view);
}
}
mChildViews = remaining;
}
}
/**
* Returns the row containing the given y line
*
* @param y the vertical position
* @return the row containing the given line
*/
public int getRow(int y) {
int row = Arrays.binarySearch(mTop, y);
if (row == -1) {
// Smaller than the first element; just use the first row
return 0;
} else if (row < 0) {
row = -(row + 2);
}
return row;
}
/**
* Returns the column containing the given x line
*
* @param x the horizontal position
* @return the column containing the given line
*/
public int getColumn(int x) {
int column = Arrays.binarySearch(mLeft, x);
if (column == -1) {
// Smaller than the first element; just use the first column
return 0;
} else if (column < 0) {
column = -(column + 2);
}
return column;
}
/**
* Returns the closest row to the given y line. This is
* either the row containing the line, or the row below it.
*
* @param y the vertical position
* @return the closest row
*/
public int getClosestRow(int y) {
int row = Arrays.binarySearch(mTop, y);
if (row == -1) {
// Smaller than the first element; just use the first column
return 0;
} else if (row < 0) {
row = -(row + 2);
}
if (getRowDistance(row, y) < getRowDistance(row + 1, y)) {
return row;
} else {
return row + 1;
}
}
/**
* Returns the closest column to the given x line. This is
* either the column containing the line, or the column following it.
*
* @param x the horizontal position
* @return the closest column
*/
public int getClosestColumn(int x) {
int column = Arrays.binarySearch(mLeft, x);
if (column == -1) {
// Smaller than the first element; just use the first column
return 0;
} else if (column < 0) {
column = -(column + 2);
}
if (getColumnDistance(column, x) < getColumnDistance(column + 1, x)) {
return column;
} else {
return column + 1;
}
}
/**
* Returns the distance between the given x position and the beginning of the given column
*
* @param column the column
* @param x the x position
* @return the distance between the two
*/
public int getColumnDistance(int column, int x) {
return abs(getColumnX(column) - x);
}
/**
* Returns the actual width of the given column. This returns the difference between
* the rightmost edge of the views (not including spacers) and the left edge of the
* column.
*
* @param column the column
* @return the actual width of the non-spacer views in the column
*/
public int getColumnActualWidth(int column) {
return getColumnMaxX(column) - getColumnX(column);
}
/**
* Returns the distance between the given y position and the top of the given row
*
* @param row the row
* @param y the y position
* @return the distance between the two
*/
public int getRowDistance(int row, int y) {
return abs(getRowY(row) - y);
}
/**
* Returns the y position of the top of the given row
*
* @param row the target row
* @return the y position of its top edge
*/
public int getRowY(int row) {
return mTop[min(mTop.length - 1, max(0, row))];
}
/**
* Returns the bottom-most edge of any of the non-spacer children in the given row
*
* @param row the target row
* @return the bottom-most edge of any of the non-spacer children in the row
*/
public int getRowMaxY(int row) {
return mMaxBottom[min(mMaxBottom.length - 1, max(0, row))];
}
/**
* Returns the actual height of the given row. This returns the difference between
* the bottom-most edge of the views (not including spacers) and the top edge of the
* row.
*
* @param row the row
* @return the actual height of the non-spacer views in the row
*/
public int getRowActualHeight(int row) {
return getRowMaxY(row) - getRowY(row);
}
/**
* Returns a list of all the nodes that intersects the rows in the range
* {@code y1 <= y <= y2}.
*
* @param y1 the starting y, inclusive
* @param y2 the ending y, inclusive
* @return a list of nodes intersecting the given rows, never null but possibly empty
*/
public Collection<INode> getIntersectsRow(int y1, int y2) {
List<INode> nodes = new ArrayList<INode>();
for (ViewData view : mChildViews) {
if (!view.isSpacer()) {
Rect bounds = view.node.getBounds();
if (bounds.y2() >= y1 && bounds.y <= y2) {
nodes.add(view.node);
}
}
}
return nodes;
}
/**
* Returns the height of the given row or rows (if the rowSpan is greater than 1)
*
* @param row the target row
* @param rowSpan the row span
* @return the height in pixels of the given rows
*/
public int getRowHeight(int row, int rowSpan) {
return getRowY(row + rowSpan) - getRowY(row);
}
/**
* Returns the x position of the left edge of the given column
*
* @param column the target column
* @return the x position of its left edge
*/
public int getColumnX(int column) {
return mLeft[min(mLeft.length - 1, max(0, column))];
}
/**
* Returns the rightmost edge of any of the non-spacer children in the given row
*
* @param column the target column
* @return the rightmost edge of any of the non-spacer children in the column
*/
public int getColumnMaxX(int column) {
return mMaxRight[min(mMaxRight.length - 1, max(0, column))];
}
/**
* Returns the width of the given column or columns (if the columnSpan is greater than 1)
*
* @param column the target column
* @param columnSpan the column span
* @return the width in pixels of the given columns
*/
public int getColumnWidth(int column, int columnSpan) {
return getColumnX(column + columnSpan) - getColumnX(column);
}
/**
* Returns the bounds of the cell at the given row and column position, with the given
* row and column spans.
*
* @param row the target row
* @param column the target column
* @param rowSpan the row span
* @param columnSpan the column span
* @return the bounds, in pixels, of the given cell
*/
public Rect getCellBounds(int row, int column, int rowSpan, int columnSpan) {
return new Rect(getColumnX(column), getRowY(row),
getColumnWidth(column, columnSpan),
getRowHeight(row, rowSpan));
}
/**
* Produces a display of view contents along with the pixel positions of each
* row/column, like the following (used for diagnostics only)
*
* <pre>
* |0 |49 |143 |192 |240
* 36| | |button2 |
* 72| |radioButton1 |button2 |
* 74|button1 |radioButton1 |button2 |
* 108|button1 | |button2 |
* 110| | |button2 |
* 149| | | |
* 320
* </pre>
*/
@Override
public String toString() {
// Dump out the view table
int cellWidth = 25;
List<List<List<ViewData>>> rowList = new ArrayList<List<List<ViewData>>>(mTop.length);
for (int row = 0; row < mTop.length; row++) {
List<List<ViewData>> columnList = new ArrayList<List<ViewData>>(mLeft.length);
for (int col = 0; col < mLeft.length; col++) {
columnList.add(new ArrayList<ViewData>(4));
}
rowList.add(columnList);
}
for (ViewData view : mChildViews) {
for (int i = 0; i < view.rowSpan; i++) {
if (view.row + i > mTop.length) { // Guard against bogus span values
break;
}
if (rowList.size() <= view.row + i) {
break;
}
for (int j = 0; j < view.columnSpan; j++) {
List<List<ViewData>> columnList = rowList.get(view.row + i);
if (columnList.size() <= view.column + j) {
break;
}
columnList.get(view.column + j).add(view);
}
}
}
StringWriter stringWriter = new StringWriter();
PrintWriter out = new PrintWriter(stringWriter);
out.printf("%" + cellWidth + "s", ""); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
for (int col = 0; col < actualColumnCount + 1; col++) {
out.printf("|%-" + (cellWidth - 1) + "d", mLeft[col]); //$NON-NLS-1$ //$NON-NLS-2$
}
out.printf("\n"); //$NON-NLS-1$
for (int row = 0; row < actualRowCount + 1; row++) {
out.printf("%" + cellWidth + "d", mTop[row]); //$NON-NLS-1$ //$NON-NLS-2$
if (row == actualRowCount) {
break;
}
for (int col = 0; col < actualColumnCount; col++) {
List<ViewData> views = rowList.get(row).get(col);
StringBuilder sb = new StringBuilder();
for (ViewData view : views) {
String id = view != null ? view.getId() : ""; //$NON-NLS-1$
if (id.startsWith(NEW_ID_PREFIX)) {
id = id.substring(NEW_ID_PREFIX.length());
}
if (id.length() > cellWidth - 2) {
id = id.substring(0, cellWidth - 2);
}
if (sb.length() > 0) {
sb.append(',');
}
sb.append(id);
}
String cellString = sb.toString();
if (cellString.contains(",") && cellString.length() > cellWidth - 2) { //$NON-NLS-1$
cellString = cellString.substring(0, cellWidth - 6) + "...,"; //$NON-NLS-1$
}
out.printf("|%-" + (cellWidth - 2) + "s ", cellString); //$NON-NLS-1$ //$NON-NLS-2$
}
out.printf("\n"); //$NON-NLS-1$
}
out.flush();
return stringWriter.toString();
}
/**
* Split a cell into two or three columns.
*
* @param newColumn The column number to insert before
* @param insertMarginColumn If false, then the cell at newColumn -1 is split with the
* left part taking up exactly columnWidthDp dips. If true, then the column
* is split twice; the left part is the implicit width of the column, the
* new middle (margin) column is exactly the columnWidthDp size and the
* right column is the remaining space of the old cell.
* @param columnWidthDp The width of the column inserted before the new column (or if
* insertMarginColumn is false, then the width of the margin column)
* @param x the x coordinate of the new column
*/
public void splitColumn(int newColumn, boolean insertMarginColumn, int columnWidthDp, int x) {
actualColumnCount++;
// Insert a new column
if (declaredColumnCount != UNDEFINED) {
declaredColumnCount++;
if (insertMarginColumn) {
declaredColumnCount++;
}
setGridAttribute(layout, ATTR_COLUMN_COUNT, declaredColumnCount);
}
// Are we inserting a new last column in the grid? That requires some special handling...
boolean isLastColumn = true;
for (ViewData view : mChildViews) {
if (view.column >= newColumn) {
isLastColumn = false;
break;
}
}
// Hardcode the row numbers if the last column is a new column such that
// they don't jump back to backfill the previous row's new last cell:
// TODO: Only do this for horizontal layouts!
if (isLastColumn) {
for (ViewData view : mChildViews) {
if (view.column == 0 && view.row > 0) {
if (getGridAttribute(view.node, ATTR_LAYOUT_ROW) == null) {
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
}
}
}
}
// Find the spacer which marks this column, and if found, mark it as a split
ViewData prevColumnSpacer = null;
for (ViewData view : mChildViews) {
if (view.column == newColumn - 1 && view.isColumnSpacer()) {
prevColumnSpacer = view;
break;
}
}
// Process all existing grid elements:
// * Increase column numbers for all columns that have a hardcoded column number
// greater than the new column
// * Set an explicit column=0 where needed (TODO: Implement this)
// * Increase the columnSpan for all columns that overlap the newly inserted column edge
// * Split the spacer which defined the size of this column into two
// (and if not found, create a new spacer)
//
for (ViewData view : mChildViews) {
if (view == prevColumnSpacer) {
continue;
}
INode node = view.node;
int column = view.column;
if (column > newColumn || (column == newColumn && view.node.getBounds().x2() > x)) {
// ALWAYS set the column, because
// (1) if it has been set, it needs to be corrected
// (2) if it has not been set, it needs to be set to cause this column
// to skip over the new column (there may be no views for the new
// column on this row).
// TODO: Enhance this such that we only set the column to a skip number
// where necessary, e.g. only on the FIRST view on this row following the
// skipped column!
//if (getGridAttribute(node, ATTR_LAYOUT_COLUMN) != null) {
view.column += insertMarginColumn ? 2 : 1;
setGridAttribute(node, ATTR_LAYOUT_COLUMN, view.column);
//}
} else if (!view.isSpacer()) {
// Adjust the column span? We must increase it if
// (1) the new column is inside the range [column, column + columnSpan]
// (2) the new column is within the last cell in the column span,
// and the exact X location of the split is within the horizontal
// *bounds* of this node (provided it has gravity=left)
// (3) the new column is within the last cell and the cell has gravity
// right or gravity center
int endColumn = column + view.columnSpan;
if (endColumn > newColumn
|| endColumn == newColumn && (view.node.getBounds().x2() > x
|| GravityHelper.isConstrainedHorizontally(view.gravity)
&& !GravityHelper.isLeftAligned(view.gravity))) {
// This cell spans the new insert position, so increment the column span
view.columnSpan += insertMarginColumn ? 2 : 1;
setColumnSpanAttribute(node, view.columnSpan);
}
}
}
// Insert new spacer:
if (prevColumnSpacer != null) {
int px = getColumnWidth(newColumn - 1, 1);
if (insertMarginColumn || columnWidthDp == 0) {
px -= getColumnActualWidth(newColumn - 1);
}
int dp = mRulesEngine.pxToDp(px);
int remaining = dp - columnWidthDp;
if (remaining > 0) {
prevColumnSpacer.node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH,
String.format(VALUE_N_DP, remaining));
prevColumnSpacer.column = insertMarginColumn ? newColumn + 1 : newColumn;
setGridAttribute(prevColumnSpacer.node, ATTR_LAYOUT_COLUMN,
prevColumnSpacer.column);
}
}
if (columnWidthDp > 0) {
int index = prevColumnSpacer != null ? prevColumnSpacer.index : -1;
addSpacer(layout, index, 0, insertMarginColumn ? newColumn : newColumn - 1,
columnWidthDp, SPACER_SIZE_DP);
}
}
/**
* Split a cell into two or three rows.
*
* @param newRow The row number to insert before
* @param insertMarginRow If false, then the cell at newRow -1 is split with the above
* part taking up exactly rowHeightDp dips. If true, then the row is split
* twice; the top part is the implicit height of the row, the new middle
* (margin) row is exactly the rowHeightDp size and the bottom column is
* the remaining space of the old cell.
* @param rowHeightDp The height of the row inserted before the new row (or if
* insertMarginRow is false, then the height of the margin row)
* @param y the y coordinate of the new row
*/
public void splitRow(int newRow, boolean insertMarginRow, int rowHeightDp, int y) {
actualRowCount++;
// Insert a new row
if (declaredRowCount != UNDEFINED) {
declaredRowCount++;
if (insertMarginRow) {
declaredRowCount++;
}
setGridAttribute(layout, ATTR_ROW_COUNT, declaredRowCount);
}
// Find the spacer which marks this row, and if found, mark it as a split
ViewData prevRowSpacer = null;
for (ViewData view : mChildViews) {
if (view.row == newRow - 1 && view.isRowSpacer()) {
prevRowSpacer = view;
break;
}
}
// Se splitColumn() for details
for (ViewData view : mChildViews) {
if (view == prevRowSpacer) {
continue;
}
INode node = view.node;
int row = view.row;
if (row > newRow || (row == newRow && view.node.getBounds().y2() > y)) {
//if (getGridAttribute(node, ATTR_LAYOUT_ROW) != null) {
view.row += insertMarginRow ? 2 : 1;
setGridAttribute(node, ATTR_LAYOUT_ROW, view.row);
//}
} else if (!view.isSpacer()) {
int endRow = row + view.rowSpan;
if (endRow > newRow
|| endRow == newRow && (view.node.getBounds().y2() > y
|| GravityHelper.isConstrainedVertically(view.gravity)
&& !GravityHelper.isTopAligned(view.gravity))) {
// This cell spans the new insert position, so increment the row span
view.rowSpan += insertMarginRow ? 2 : 1;
setRowSpanAttribute(node, view.rowSpan);
}
}
}
// Insert new spacer:
if (prevRowSpacer != null) {
int px = getRowHeight(newRow - 1, 1);
if (insertMarginRow || rowHeightDp == 0) {
px -= getRowActualHeight(newRow - 1);
}
int dp = mRulesEngine.pxToDp(px);
int remaining = dp - rowHeightDp;
if (remaining > 0) {
prevRowSpacer.node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT,
String.format(VALUE_N_DP, remaining));
prevRowSpacer.row = insertMarginRow ? newRow + 1 : newRow;
setGridAttribute(prevRowSpacer.node, ATTR_LAYOUT_ROW, prevRowSpacer.row);
}
}
if (rowHeightDp > 0) {
int index = prevRowSpacer != null ? prevRowSpacer.index : -1;
addSpacer(layout, index, insertMarginRow ? newRow : newRow - 1,
0, SPACER_SIZE_DP, rowHeightDp);
}
}
/**
* Data about a view in a table; this is not the same as a cell because multiple views
* can share a single cell, and a view can span many cells.
*/
class ViewData {
public final INode node;
public final int index;
public int row;
public int column;
public int rowSpan;
public int columnSpan;
public int gravity;
ViewData(INode n, int index) {
node = n;
this.index = index;
column = getGridAttribute(n, ATTR_LAYOUT_COLUMN, UNDEFINED);
columnSpan = getGridAttribute(n, ATTR_LAYOUT_COLUMN_SPAN, 1);
row = getGridAttribute(n, ATTR_LAYOUT_ROW, UNDEFINED);
rowSpan = getGridAttribute(n, ATTR_LAYOUT_ROW_SPAN, 1);
gravity = GravityHelper.getGravity(getGridAttribute(n, ATTR_LAYOUT_GRAVITY), 0);
}
/** Applies the column and row fields into the XML model */
void applyPositionAttributes() {
setGridAttribute(node, ATTR_LAYOUT_COLUMN, column);
setGridAttribute(node, ATTR_LAYOUT_ROW, row);
}
/** Returns the id of this node, or makes one up for display purposes */
String getId() {
String id = node.getStringAttr(ANDROID_URI, ATTR_ID);
if (id == null) {
id = "<unknownid>"; //$NON-NLS-1$
String fqn = node.getFqcn();
fqn = fqn.substring(fqn.lastIndexOf('.') + 1);
id = fqn + "-"
+ Integer.toString(System.identityHashCode(node)).substring(0, 3);
}
return id;
}
/** Returns true if this {@link ViewData} represents a spacer */
boolean isSpacer() {
return isSpace(node.getFqcn());
}
/**
* Returns true if this {@link ViewData} represents a column spacer
*/
boolean isColumnSpacer() {
return isSpacer() &&
// Any spacer not found in column 0 is a column spacer since we
// place all horizontal spacers in column 0
((column > 0)
// TODO: Find a cleaner way. Maybe set ids on the elements in (0,0) and
// for column distinguish by id. Or at least only do this for column 0!
|| !SPACER_SIZE.equals(node.getStringAttr(ANDROID_URI, ATTR_LAYOUT_WIDTH)));
}
/**
* Returns true if this {@link ViewData} represents a row spacer
*/
boolean isRowSpacer() {
return isSpacer() &&
// Any spacer not found in row 0 is a row spacer since we
// place all vertical spacers in row 0
((row > 0)
// TODO: Find a cleaner way. Maybe set ids on the elements in (0,0) and
// for column distinguish by id. Or at least only do this for column 0!
|| !SPACER_SIZE.equals(node.getStringAttr(ANDROID_URI, ATTR_LAYOUT_HEIGHT)));
}
}
/**
* Sets the column span of the given node to the given value (or if the value is 1,
* removes it)
*
* @param node the target node
* @param span the new column span
*/
public void setColumnSpanAttribute(INode node, int span) {
setGridAttribute(node, ATTR_LAYOUT_COLUMN_SPAN, span > 1 ? Integer.toString(span) : null);
}
/**
* Sets the row span of the given node to the given value (or if the value is 1,
* removes it)
*
* @param node the target node
* @param span the new row span
*/
public void setRowSpanAttribute(INode node, int span) {
setGridAttribute(node, ATTR_LAYOUT_ROW_SPAN, span > 1 ? Integer.toString(span) : null);
}
/** Returns the index of the given target node in the given child node array */
static int getChildIndex(INode[] children, INode target) {
int index = 0;
for (INode child : children) {
if (child == target) {
return index;
}
index++;
}
return -1;
}
/**
* Update the model to account for the given nodes getting deleted. The nodes
* are not actually deleted by this method; that is assumed to be performed by the
* caller. Instead this method performs whatever model updates are necessary to
* preserve the grid structure.
*
* @param nodes the nodes to be deleted
*/
public void onDeleted(@NonNull List<INode> nodes) {
if (nodes.size() == 0) {
return;
}
// Attempt to clean up spacer objects for any newly-empty rows or columns
// as the result of this deletion
Set<INode> deleted = new HashSet<INode>();
for (INode child : nodes) {
// We don't care about deletion of spacers
String fqcn = child.getFqcn();
if (fqcn.equals(FQCN_SPACE) || fqcn.equals(FQCN_SPACE_V7)) {
continue;
}
deleted.add(child);
}
Set<Integer> usedColumns = new HashSet<Integer>(actualColumnCount);
Set<Integer> usedRows = new HashSet<Integer>(actualRowCount);
Multimap<Integer, ViewData> columnSpacers = ArrayListMultimap.create(actualColumnCount, 2);
Multimap<Integer, ViewData> rowSpacers = ArrayListMultimap.create(actualRowCount, 2);
Set<ViewData> removedViews = new HashSet<ViewData>();
for (ViewData view : mChildViews) {
if (deleted.contains(view.node)) {
removedViews.add(view);
} else if (view.isColumnSpacer()) {
columnSpacers.put(view.column, view);
} else if (view.isRowSpacer()) {
rowSpacers.put(view.row, view);
} else {
usedColumns.add(Integer.valueOf(view.column));
usedRows.add(Integer.valueOf(view.row));
}
}
if (usedColumns.size() == 0 || usedRows.size() == 0) {
// No more views - just remove all the spacers
for (ViewData spacer : columnSpacers.values()) {
layout.removeChild(spacer.node);
}
for (ViewData spacer : rowSpacers.values()) {
layout.removeChild(spacer.node);
}
mChildViews.clear();
actualColumnCount = 0;
declaredColumnCount = 2;
actualRowCount = 0;
declaredRowCount = UNDEFINED;
setGridAttribute(layout, ATTR_COLUMN_COUNT, 2);
return;
}
// Determine columns to introduce spacers into:
// This is tricky; I should NOT combine spacers if there are cells tied to
// individual ones
// TODO: Invalidate column sizes too! Otherwise repeated updates might get confused!
// Similarly, inserts need to do the same!
// Produce map of old column numbers to new column numbers
// Collapse regions of consecutive space and non-space ranges together
int[] columnMap = new int[actualColumnCount + 1]; // +1: Easily handle columnSpans as well
int newColumn = 0;
boolean prevUsed = usedColumns.contains(0);
for (int column = 1; column < actualColumnCount; column++) {
boolean used = usedColumns.contains(column);
if (used || prevUsed != used) {
newColumn++;
prevUsed = used;
}
columnMap[column] = newColumn;
}
newColumn++;
columnMap[actualColumnCount] = newColumn;
assert columnMap[0] == 0;
int[] rowMap = new int[actualRowCount + 1]; // +1: Easily handle rowSpans as well
int newRow = 0;
prevUsed = usedRows.contains(0);
for (int row = 1; row < actualRowCount; row++) {
boolean used = usedRows.contains(row);
if (used || prevUsed != used) {
newRow++;
prevUsed = used;
}
rowMap[row] = newRow;
}
newRow++;
rowMap[actualRowCount] = newRow;
assert rowMap[0] == 0;
// Adjust column and row numbers to account for deletions: for a given cell, if it
// is to the right of a deleted column, reduce its column number, and if it only
// spans across the deleted column, reduce its column span.
for (ViewData view : mChildViews) {
if (removedViews.contains(view)) {
continue;
}
int newColumnStart = columnMap[Math.min(columnMap.length - 1, view.column)];
// Gracefully handle rogue/invalid columnSpans in the XML
int newColumnEnd = columnMap[Math.min(columnMap.length - 1,
view.column + view.columnSpan)];
if (newColumnStart != view.column) {
view.column = newColumnStart;
setGridAttribute(view.node, ATTR_LAYOUT_COLUMN, view.column);
}
int columnSpan = newColumnEnd - newColumnStart;
if (columnSpan != view.columnSpan) {
if (columnSpan >= 1) {
view.columnSpan = columnSpan;
setColumnSpanAttribute(view.node, view.columnSpan);
} // else: merging spacing columns together
}
int newRowStart = rowMap[Math.min(rowMap.length - 1, view.row)];
int newRowEnd = rowMap[Math.min(rowMap.length - 1, view.row + view.rowSpan)];
if (newRowStart != view.row) {
view.row = newRowStart;
setGridAttribute(view.node, ATTR_LAYOUT_ROW, view.row);
}
int rowSpan = newRowEnd - newRowStart;
if (rowSpan != view.rowSpan) {
if (rowSpan >= 1) {
view.rowSpan = rowSpan;
setRowSpanAttribute(view.node, view.rowSpan);
} // else: merging spacing rows together
}
}
// Merge spacers (and add spacers for newly empty columns)
int start = 0;
while (start < actualColumnCount) {
// Find next unused span
while (start < actualColumnCount && usedColumns.contains(start)) {
start++;
}
if (start == actualColumnCount) {
break;
}
assert !usedColumns.contains(start);
// Find the next span of unused columns and produce a SINGLE
// spacer for that range (unless it's a zero-sized columns)
int end = start + 1;
for (; end < actualColumnCount; end++) {
if (usedColumns.contains(end)) {
break;
}
}
// Add up column sizes
int width = getColumnWidth(start, end - start);
// Find all spacers: the first one found should be moved to the start column
// and assigned to the full height of the columns, and
// the column count reduced by the corresponding amount
// TODO: if width = 0, fully remove
boolean isFirstSpacer = true;
for (int column = start; column < end; column++) {
Collection<ViewData> spacers = columnSpacers.get(column);
if (spacers != null && !spacers.isEmpty()) {
// Avoid ConcurrentModificationException since we're inserting into the
// map within this loop (always at a different index, but the map doesn't
// know that)
spacers = new ArrayList<ViewData>(spacers);
for (ViewData spacer : spacers) {
if (isFirstSpacer) {
isFirstSpacer = false;
spacer.column = columnMap[start];
setGridAttribute(spacer.node, ATTR_LAYOUT_COLUMN, spacer.column);
if (end - start > 1) {
// Compute a merged width for all the spacers (not needed if
// there's just one spacer; it should already have the correct width)
int columnWidthDp = mRulesEngine.pxToDp(width);
spacer.node.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH,
String.format(VALUE_N_DP, columnWidthDp));
}
columnSpacers.put(start, spacer);
} else {
removedViews.add(spacer); // Mark for model removal
layout.removeChild(spacer.node);
}
}
}
}
if (isFirstSpacer) {
// No spacer: create one
int columnWidthDp = mRulesEngine.pxToDp(width);
addSpacer(layout, -1, UNDEFINED, columnMap[start], columnWidthDp, DEFAULT_CELL_HEIGHT);
}
start = end;
}
actualColumnCount = newColumn;
//if (usedColumns.contains(newColumn)) {
// // TODO: This may be totally wrong for right aligned content!
// actualColumnCount++;
//}
// Merge spacers for rows
start = 0;
while (start < actualRowCount) {
// Find next unused span
while (start < actualRowCount && usedRows.contains(start)) {
start++;
}
if (start == actualRowCount) {
break;
}
assert !usedRows.contains(start);
// Find the next span of unused rows and produce a SINGLE
// spacer for that range (unless it's a zero-sized rows)
int end = start + 1;
for (; end < actualRowCount; end++) {
if (usedRows.contains(end)) {
break;
}
}
// Add up row sizes
int height = getRowHeight(start, end - start);
// Find all spacers: the first one found should be moved to the start row
// and assigned to the full height of the rows, and
// the row count reduced by the corresponding amount
// TODO: if width = 0, fully remove
boolean isFirstSpacer = true;
for (int row = start; row < end; row++) {
Collection<ViewData> spacers = rowSpacers.get(row);
if (spacers != null && !spacers.isEmpty()) {
// Avoid ConcurrentModificationException since we're inserting into the
// map within this loop (always at a different index, but the map doesn't
// know that)
spacers = new ArrayList<ViewData>(spacers);
for (ViewData spacer : spacers) {
if (isFirstSpacer) {
isFirstSpacer = false;
spacer.row = rowMap[start];
setGridAttribute(spacer.node, ATTR_LAYOUT_ROW, spacer.row);
if (end - start > 1) {
// Compute a merged width for all the spacers (not needed if
// there's just one spacer; it should already have the correct height)
int rowHeightDp = mRulesEngine.pxToDp(height);
spacer.node.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT,
String.format(VALUE_N_DP, rowHeightDp));
}
rowSpacers.put(start, spacer);
} else {
removedViews.add(spacer); // Mark for model removal
layout.removeChild(spacer.node);
}
}
}
}
if (isFirstSpacer) {
// No spacer: create one
int rowWidthDp = mRulesEngine.pxToDp(height);
addSpacer(layout, -1, rowMap[start], UNDEFINED, DEFAULT_CELL_WIDTH, rowWidthDp);
}
start = end;
}
actualRowCount = newRow;
// if (usedRows.contains(newRow)) {
// actualRowCount++;
// }
// Update the model: remove removed children from the view data list
if (removedViews.size() <= 2) {
mChildViews.removeAll(removedViews);
} else {
List<ViewData> remaining =
new ArrayList<ViewData>(mChildViews.size() - removedViews.size());
for (ViewData view : mChildViews) {
if (!removedViews.contains(view)) {
remaining.add(view);
}
}
mChildViews = remaining;
}
// Update the final column and row declared attributes
if (declaredColumnCount != UNDEFINED) {
declaredColumnCount = actualColumnCount;
setGridAttribute(layout, ATTR_COLUMN_COUNT, actualColumnCount);
}
if (declaredRowCount != UNDEFINED) {
declaredRowCount = actualRowCount;
setGridAttribute(layout, ATTR_ROW_COUNT, actualRowCount);
}
}
/**
* Adds a spacer to the given parent, at the given index.
*
* @param parent the GridLayout
* @param index the index to insert the spacer at, or -1 to append
* @param row the row to add the spacer to (or {@link #UNDEFINED} to not set a row yet
* @param column the column to add the spacer to (or {@link #UNDEFINED} to not set a
* column yet
* @param widthDp the width in device independent pixels to assign to the spacer
* @param heightDp the height in device independent pixels to assign to the spacer
* @return the newly added spacer
*/
ViewData addSpacer(INode parent, int index, int row, int column,
int widthDp, int heightDp) {
INode spacer;
String tag = FQCN_SPACE;
String gridLayout = parent.getFqcn();
if (!gridLayout.equals(GRID_LAYOUT) && gridLayout.length() > GRID_LAYOUT.length()) {
String pkg = gridLayout.substring(0, gridLayout.length() - GRID_LAYOUT.length());
tag = pkg + SPACE;
}
if (index != -1) {
spacer = parent.insertChildAt(tag, index);
} else {
spacer = parent.appendChild(tag);
}
ViewData view = new ViewData(spacer, index != -1 ? index : mChildViews.size());
mChildViews.add(view);
if (row != UNDEFINED) {
view.row = row;
setGridAttribute(spacer, ATTR_LAYOUT_ROW, row);
}
if (column != UNDEFINED) {
view.column = column;
setGridAttribute(spacer, ATTR_LAYOUT_COLUMN, column);
}
if (widthDp > 0) {
spacer.setAttribute(ANDROID_URI, ATTR_LAYOUT_WIDTH,
String.format(VALUE_N_DP, widthDp));
}
if (heightDp > 0) {
spacer.setAttribute(ANDROID_URI, ATTR_LAYOUT_HEIGHT,
String.format(VALUE_N_DP, heightDp));
}
// Temporary hack
if (GridLayoutRule.sDebugGridLayout) {
//String id = NEW_ID_PREFIX + "s";
//if (row == 0) {
// id += "c";
//}
//if (column == 0) {
// id += "r";
//}
//if (row > 0) {
// id += Integer.toString(row);
//}
//if (column > 0) {
// id += Integer.toString(column);
//}
String id = NEW_ID_PREFIX + "spacer_" //$NON-NLS-1$
+ Integer.toString(System.identityHashCode(spacer)).substring(0, 3);
spacer.setAttribute(ANDROID_URI, ATTR_ID, id);
}
return view;
}
/**
* Returns the string value of the given attribute, or null if it does not
* exist. This only works for attributes that are GridLayout specific, such
* as columnCount, layout_column, layout_row_span, etc.
*
* @param node the target node
* @param name the attribute name (which must be in the android: namespace)
* @return the attribute value or null
*/
public String getGridAttribute(INode node, String name) {
return node.getStringAttr(getNamespace(), name);
}
/**
* Returns the integer value of the given attribute, or the given defaultValue if the
* attribute was not set. This only works for attributes that are GridLayout specific,
* such as columnCount, layout_column, layout_row_span, etc.
*
* @param node the target node
* @param attribute the attribute name (which must be in the android: namespace)
* @param defaultValue the default value to use if the value is not set
* @return the attribute integer value
*/
private int getGridAttribute(INode node, String attribute, int defaultValue) {
String valueString = node.getStringAttr(getNamespace(), attribute);
if (valueString != null) {
try {
return Integer.decode(valueString);
} catch (NumberFormatException nufe) {
// Ignore - error in user's XML
}
}
return defaultValue;
}
/**
* Returns the number of children views in the GridLayout
*
* @return the number of children views in the GridLayout
*/
public int getViewCount() {
return mChildViews.size();
}
/**
* Returns true if the given class name represents a spacer
*
* @param fqcn the fully qualified class name
* @return true if this is a spacer
*/
public static boolean isSpace(String fqcn) {
return FQCN_SPACE.equals(fqcn) || FQCN_SPACE_V7.equals(fqcn);
}
}