merge in jb-release history after reset to master
diff --git a/src/com/android/launcher2/CellLayout.java b/src/com/android/launcher2/CellLayout.java
index 745c81b..d30940e 100644
--- a/src/com/android/launcher2/CellLayout.java
+++ b/src/com/android/launcher2/CellLayout.java
@@ -888,25 +888,11 @@
* @param result Array of 2 ints to hold the x and y coordinate of the point
*/
void cellToCenterPoint(int cellX, int cellY, int[] result) {
- regionToCenterPoint(cellX, cellY, 1, 1, result);
- }
-
- /**
- * Given a cell coordinate and span return the point that represents the center of the regio
- *
- * @param cellX X coordinate of the cell
- * @param cellY Y coordinate of the cell
- *
- * @param result Array of 2 ints to hold the x and y coordinate of the point
- */
- void regionToCenterPoint(int cellX, int cellY, int spanX, int spanY, int[] result) {
final int hStartPadding = getPaddingLeft();
final int vStartPadding = getPaddingTop();
- result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap) +
- (spanX * mCellWidth + (spanX - 1) * mWidthGap) / 2;
- result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap) +
- (spanY * mCellHeight + (spanY - 1) * mHeightGap) / 2;
+ result[0] = hStartPadding + cellX * (mCellWidth + mWidthGap) + mCellWidth / 2;
+ result[1] = vStartPadding + cellY * (mCellHeight + mHeightGap) + mCellHeight / 2;
}
public float getDistanceFromCell(float x, float y, int[] cell) {
@@ -1486,23 +1472,20 @@
* desired location. This method computers distance based on unit grid distances,
* not pixel distances.
*
- * @param cellX The X cell nearest to which you want to search for a vacant area.
- * @param cellY The Y cell nearest which you want to search for a vacant area.
+ * @param pixelX The X location at which you want to search for a vacant area.
+ * @param pixelY The Y location at which you want to search for a vacant area.
+ * @param minSpanX The minimum horizontal span required
+ * @param minSpanY The minimum vertical span required
* @param spanX Horizontal span of the object.
* @param spanY Vertical span of the object.
- * @param direction The favored direction in which the views should move from x, y
- * @param exactDirectionOnly If this parameter is true, then only solutions where the direction
- * matches exactly. Otherwise we find the best matching direction.
- * @param occoupied The array which represents which cells in the CellLayout are occupied
- * @param blockOccupied The array which represents which cells in the specified block (cellX,
- * cellY, spanX, spanY) are occupied. This is used when try to move a group of views.
+ * @param ignoreOccupied If true, the result can be an occupied cell
* @param result Array in which to place the result, or null (in which case a new array will
* be allocated)
* @return The X, Y cell of a vacant area that can contain this object,
* nearest the requested location.
*/
private int[] findNearestArea(int cellX, int cellY, int spanX, int spanY, int[] direction,
- boolean[][] occupied, boolean blockOccupied[][], int[] result) {
+ boolean[][] occupied, int[] result) {
// Keep track of best-scoring drop area
final int[] bestXY = result != null ? result : new int[2];
float bestDistance = Float.MAX_VALUE;
@@ -1517,7 +1500,7 @@
// First, let's see if this thing fits anywhere
for (int i = 0; i < spanX; i++) {
for (int j = 0; j < spanY; j++) {
- if (occupied[x + i][y + j] && (blockOccupied == null || blockOccupied[i][j])) {
+ if (occupied[x + i][y + j]) {
continue inner;
}
}
@@ -1526,16 +1509,11 @@
float distance = (float)
Math.sqrt((x - cellX) * (x - cellX) + (y - cellY) * (y - cellY));
int[] curDirection = mTmpPoint;
- computeDirectionVector(x - cellX, y - cellY, curDirection);
- // The direction score is just the dot product of the two candidate direction
- // and that passed in.
+ computeDirectionVector(cellX, cellY, x, y, curDirection);
int curDirectionScore = direction[0] * curDirection[0] +
direction[1] * curDirection[1];
- boolean exactDirectionOnly = false;
- boolean directionMatches = direction[0] == curDirection[0] &&
- direction[0] == curDirection[0];
- if ((directionMatches || !exactDirectionOnly) &&
- Float.compare(distance, bestDistance) < 0 || (Float.compare(distance,
+
+ if (Float.compare(distance, bestDistance) < 0 || (Float.compare(distance,
bestDistance) == 0 && curDirectionScore > bestDirectionScore)) {
bestDistance = distance;
bestDirectionScore = curDirectionScore;
@@ -1553,48 +1531,6 @@
return bestXY;
}
- private int[] findNearestAreaInDirection(int cellX, int cellY, int spanX, int spanY,
- int[] direction,boolean[][] occupied,
- boolean blockOccupied[][], int[] result) {
- // Keep track of best-scoring drop area
- final int[] bestXY = result != null ? result : new int[2];
- bestXY[0] = -1;
- bestXY[1] = -1;
- float bestDistance = Float.MAX_VALUE;
-
- // We use this to march in a single direction
- if (direction[0] != 0 && direction[1] != 0) {
- return bestXY;
- }
-
- // This will only incrememnet one of x or y based on the assertion above
- int x = cellX + direction[0];
- int y = cellY + direction[1];
- while (x >= 0 && x + spanX <= mCountX && y >= 0 && y + spanY <= mCountY) {
-
- boolean fail = false;
- for (int i = 0; i < spanX; i++) {
- for (int j = 0; j < spanY; j++) {
- if (occupied[x + i][y + j] && (blockOccupied == null || blockOccupied[i][j])) {
- fail = true;
- }
- }
- }
- if (!fail) {
- float distance = (float)
- Math.sqrt((x - cellX) * (x - cellX) + (y - cellY) * (y - cellY));
- if (Float.compare(distance, bestDistance) < 0) {
- bestDistance = distance;
- bestXY[0] = x;
- bestXY[1] = y;
- }
- }
- x += direction[0];
- y += direction[1];
- }
- return bestXY;
- }
-
private boolean addViewToTempLocation(View v, Rect rectOccupiedByPotentialDrop,
int[] direction) {
LayoutParams lp = (LayoutParams) v.getLayoutParams();
@@ -1604,7 +1540,7 @@
markCellsForRect(rectOccupiedByPotentialDrop, mTmpOccupied, true);
findNearestArea(lp.tmpCellX, lp.tmpCellY, lp.cellHSpan, lp.cellVSpan,
- direction, mTmpOccupied, null, mTempLocation);
+ direction, mTmpOccupied, mTempLocation);
if (mTempLocation[0] >= 0 && mTempLocation[1] >= 0) {
lp.tmpCellX = mTempLocation[0];
@@ -1617,124 +1553,6 @@
return success;
}
- // This method looks in the specified direction to see if there is an additional view
- // immediately adjecent in that direction
- private boolean addViewInDirection(ArrayList<View> views, Rect boundingRect, int[] direction,
- boolean[][] occupied) {
- boolean found = false;
-
- int childCount = mChildren.getChildCount();
- Rect r0 = new Rect(boundingRect);
- Rect r1 = new Rect();
-
- int deltaX = 0;
- int deltaY = 0;
- if (direction[1] < 0) {
- r0.set(r0.left, r0.top - 1, r0.right, r0.bottom);
- deltaY = -1;
- } else if (direction[1] > 0) {
- r0.set(r0.left, r0.top, r0.right, r0.bottom + 1);
- deltaY = 1;
- } else if (direction[0] < 0) {
- r0.set(r0.left - 1, r0.top, r0.right, r0.bottom);
- deltaX = -1;
- } else if (direction[0] > 0) {
- r0.set(r0.left, r0.top, r0.right + 1, r0.bottom);
- deltaX = 1;
- }
-
- for (int i = 0; i < childCount; i++) {
- View child = mChildren.getChildAt(i);
- if (views.contains(child)) continue;
- LayoutParams lp = (LayoutParams) child.getLayoutParams();
-
- r1.set(lp.tmpCellX, lp.tmpCellY, lp.tmpCellX + lp.cellHSpan, lp.tmpCellY + lp.cellVSpan);
- if (Rect.intersects(r0, r1)) {
- if (!lp.canReorder) {
- return false;
- }
- boolean pushed = false;
- for (int x = lp.tmpCellX; x < lp.tmpCellX + lp.cellHSpan; x++) {
- for (int y = lp.tmpCellY; y < lp.tmpCellY + lp.cellVSpan; y++) {
- boolean inBounds = x - deltaX >= 0 && x -deltaX < mCountX
- && y - deltaY >= 0 && y - deltaY < mCountY;
- if (inBounds && occupied[x - deltaX][y - deltaY]) {
- pushed = true;
- }
- }
- }
- if (pushed) {
- views.add(child);
- boundingRect.union(lp.tmpCellX, lp.tmpCellY, lp.tmpCellX + lp.cellHSpan,
- lp.tmpCellY + lp.cellVSpan);
- found = true;
- }
- }
- }
- return found;
- }
-
- private boolean pushViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop,
- int[] direction) {
- if (views.size() == 0) return true;
-
-
- boolean success = false;
-
- // We construct a rect which represents the entire group of views
- Rect boundingRect = null;
- for (View v: views) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- if (boundingRect == null) {
- boundingRect = new Rect(lp.tmpCellX, lp.tmpCellY, lp.tmpCellX + lp.cellHSpan,
- lp.tmpCellY + lp.cellVSpan);
- } else {
- boundingRect.union(lp.tmpCellX, lp.tmpCellY, lp.tmpCellX + lp.cellHSpan,
- lp.tmpCellY + lp.cellVSpan);
- }
- }
-
- ArrayList<View> dup = (ArrayList<View>) views.clone();
- while (addViewInDirection(dup, boundingRect, direction, mTmpOccupied)) {
- }
- for (View v: dup) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- markCellsForView(lp.tmpCellX, lp.tmpCellY, lp.cellHSpan,
- lp.cellVSpan, mTmpOccupied, false);
- }
-
- boolean[][] blockOccupied = new boolean[boundingRect.width()][boundingRect.height()];
- int top = boundingRect.top;
- int left = boundingRect.left;
- for (View v: dup) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- markCellsForView(lp.tmpCellX - left, lp.tmpCellY - top, lp.cellHSpan,
- lp.cellVSpan, blockOccupied, true);
- }
-
- markCellsForRect(rectOccupiedByPotentialDrop, mTmpOccupied, true);
-
- findNearestAreaInDirection(boundingRect.left, boundingRect.top, boundingRect.width(),
- boundingRect.height(), direction, mTmpOccupied, blockOccupied, mTempLocation);
-
- int deltaX = mTempLocation[0] - boundingRect.left;
- int deltaY = mTempLocation[1] - boundingRect.top;
- if (mTempLocation[0] >= 0 && mTempLocation[1] >= 0) {
- for (View v: dup) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- lp.tmpCellX += deltaX;
- lp.tmpCellY += deltaY;
- }
- success = true;
- }
- for (View v: dup) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- markCellsForView(lp.tmpCellX, lp.tmpCellY, lp.cellHSpan,
- lp.cellVSpan, mTmpOccupied, true);
- }
- return success;
- }
-
private boolean addViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop,
int[] direction) {
if (views.size() == 0) return true;
@@ -1754,21 +1572,12 @@
lp.tmpCellY + lp.cellVSpan);
}
}
- boolean[][] blockOccupied = new boolean[boundingRect.width()][boundingRect.height()];
- int top = boundingRect.top;
- int left = boundingRect.left;
- for (View v: views) {
- LayoutParams lp = (LayoutParams) v.getLayoutParams();
- markCellsForView(lp.tmpCellX - left, lp.tmpCellY - top, lp.cellHSpan,
- lp.cellVSpan, blockOccupied, true);
- }
-
markCellsForRect(rectOccupiedByPotentialDrop, mTmpOccupied, true);
// TODO: this bounding rect may not be completely filled, lets be more precise about this
// check.
- findNearestArea(boundingRect.left, boundingRect.top, boundingRect.width(),
- boundingRect.height(), direction, mTmpOccupied, blockOccupied, mTempLocation);
+ findNearestArea(boundingRect.left, boundingRect.top, boundingRect.width(), boundingRect.height(),
+ direction, mTmpOccupied, mTempLocation);
int deltaX = mTempLocation[0] - boundingRect.left;
int deltaY = mTempLocation[1] - boundingRect.top;
@@ -1797,6 +1606,7 @@
mIntersectingViews.clear();
mOccupiedRect.set(cellX, cellY, cellX + spanX, cellY + spanY);
+ markCellsForRect(mOccupiedRect, mTmpOccupied, true);
if (ignoreView != null) {
LayoutParams lp = (LayoutParams) ignoreView.getLayoutParams();
@@ -1819,25 +1629,10 @@
mIntersectingViews.add(child);
}
}
-
- if (pushViewsToTempLocation(mIntersectingViews, mOccupiedRect, direction)) {
- return true;
- }
- // Try the opposite direction
- direction[0] *= -1;
- direction[1] *= -1;
- if (pushViewsToTempLocation(mIntersectingViews, mOccupiedRect, direction)) {
- return true;
- }
- // Switch the direction back
- direction[0] *= -1;
- direction[1] *= -1;
-
// First we try moving the views as a block
if (addViewsToTempLocation(mIntersectingViews, mOccupiedRect, direction)) {
return true;
}
-
// Ok, they couldn't move as a block, let's move them individually
for (View v : mIntersectingViews) {
if (!addViewToTempLocation(v, mOccupiedRect, direction)) {
@@ -1851,7 +1646,10 @@
* Returns a pair (x, y), where x,y are in {-1, 0, 1} corresponding to vector between
* the provided point and the provided cell
*/
- private void computeDirectionVector(float deltaX, float deltaY, int[] result) {
+ private void computeDirectionVector(int x0, int y0, int x1, int y1, int[] result) {
+ int deltaX = x1 - x0;
+ int deltaY = y1 - y0;
+
double angle = Math.atan(((float) deltaY) / deltaX);
result[0] = 0;
@@ -2029,22 +1827,25 @@
public void prepareChildForDrag(View child) {
markCellsAsUnoccupiedForView(child);
+ LayoutParams lp = (LayoutParams) child.getLayoutParams();
+ lp.cellX = -1;
+ lp.cellY = -1;
+
}
int[] createArea(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX, int spanY,
View dragView, int[] result, int resultSpan[], int mode) {
// First we determine if things have moved enough to cause a different layout
- result = findNearestArea(pixelX, pixelY, spanX, spanY, result);
+ result = findNearestArea(pixelX, pixelY, 1, 1, result);
if (resultSpan == null) {
resultSpan = new int[2];
}
// We attempt the first algorithm
- regionToCenterPoint(result[0], result[1], spanX, spanY, mTmpPoint);
- computeDirectionVector((mTmpPoint[0] - pixelX) / spanX, (mTmpPoint[1] - pixelY) / spanY,
- mDirectionVector);
+ cellToCenterPoint(result[0], result[1], mTmpPoint);
+ computeDirectionVector(pixelX, pixelY, mTmpPoint[0], mTmpPoint[1], mDirectionVector);
ItemConfiguration swapSolution = simpleSwap(pixelX, pixelY, minSpanX, minSpanY,
spanX, spanY, mDirectionVector, dragView, true, new ItemConfiguration());