Tony Wickham
6cbd22279e
The All Apps button creates a number of edge cases, mainly because it causes the hotseat to sometimes have an extra column than the workspace. Previously, we sort of swept these problems under the rug by simply ignoring the All Apps button if other icons were present in the hotseat, with the assumption that those other icons should get focus instead of the All Apps button. (If possible, we want to stay in the same column when moving from the workspace to the hotseat.) But this doesn't always work, as in the attached bug where the hotseat doesn't get focus at all when the All Apps button is an obvious candidate for it. By adding a specialized column in the focus matrix for the All Apps button, we ensure that moving down to the hotseat stays within the original column when possible, while also allowing the focus to switch to the All Apps button if appropriate. Furthermore, we take care to skip over the All Apps column when necessary in order to maintain all previous functionality. Bug: 25590522 Change-Id: I5d6a8ee69de8834314c4689246fe7d54329b2eef
563 lines
21 KiB
Java
563 lines
21 KiB
Java
/*
|
|
* Copyright (C) 2015 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.launcher3.util;
|
|
|
|
import android.util.Log;
|
|
import android.view.KeyEvent;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
|
|
import com.android.launcher3.CellLayout;
|
|
import com.android.launcher3.ShortcutAndWidgetContainer;
|
|
|
|
import java.util.Arrays;
|
|
|
|
/**
|
|
* Calculates the next item that a {@link KeyEvent} should change the focus to.
|
|
*<p>
|
|
* Note, this utility class calculates everything regards to icon index and its (x,y) coordinates.
|
|
* Currently supports:
|
|
* <ul>
|
|
* <li> full matrix of cells that are 1x1
|
|
* <li> sparse matrix of cells that are 1x1
|
|
* [ 1][ ][ 2][ ]
|
|
* [ ][ ][ 3][ ]
|
|
* [ ][ 4][ ][ ]
|
|
* [ ][ 5][ 6][ 7]
|
|
* </ul>
|
|
* *<p>
|
|
* For testing, one can use a BT keyboard, or use following adb command.
|
|
* ex. $ adb shell input keyevent 20 // KEYCODE_DPAD_LEFT
|
|
*/
|
|
public class FocusLogic {
|
|
|
|
private static final String TAG = "FocusLogic";
|
|
private static final boolean DEBUG = false;
|
|
|
|
/** Item and page index related constant used by {@link #handleKeyEvent}. */
|
|
public static final int NOOP = -1;
|
|
|
|
public static final int PREVIOUS_PAGE_RIGHT_COLUMN = -2;
|
|
public static final int PREVIOUS_PAGE_FIRST_ITEM = -3;
|
|
public static final int PREVIOUS_PAGE_LAST_ITEM = -4;
|
|
public static final int PREVIOUS_PAGE_LEFT_COLUMN = -5;
|
|
|
|
public static final int CURRENT_PAGE_FIRST_ITEM = -6;
|
|
public static final int CURRENT_PAGE_LAST_ITEM = -7;
|
|
|
|
public static final int NEXT_PAGE_FIRST_ITEM = -8;
|
|
public static final int NEXT_PAGE_LEFT_COLUMN = -9;
|
|
public static final int NEXT_PAGE_RIGHT_COLUMN = -10;
|
|
|
|
public static final int ALL_APPS_COLUMN = -11;
|
|
|
|
// Matrix related constant.
|
|
public static final int EMPTY = -1;
|
|
public static final int PIVOT = 100;
|
|
|
|
/**
|
|
* Returns true only if this utility class handles the key code.
|
|
*/
|
|
public static boolean shouldConsume(int keyCode) {
|
|
return (keyCode == KeyEvent.KEYCODE_DPAD_LEFT || keyCode == KeyEvent.KEYCODE_DPAD_RIGHT ||
|
|
keyCode == KeyEvent.KEYCODE_DPAD_UP || keyCode == KeyEvent.KEYCODE_DPAD_DOWN ||
|
|
keyCode == KeyEvent.KEYCODE_MOVE_HOME || keyCode == KeyEvent.KEYCODE_MOVE_END ||
|
|
keyCode == KeyEvent.KEYCODE_PAGE_UP || keyCode == KeyEvent.KEYCODE_PAGE_DOWN ||
|
|
keyCode == KeyEvent.KEYCODE_DEL || keyCode == KeyEvent.KEYCODE_FORWARD_DEL);
|
|
}
|
|
|
|
public static int handleKeyEvent(int keyCode, int cntX, int cntY,
|
|
int [][] map, int iconIdx, int pageIndex, int pageCount, boolean isRtl) {
|
|
|
|
if (DEBUG) {
|
|
Log.v(TAG, String.format(
|
|
"handleKeyEvent START: cntX=%d, cntY=%d, iconIdx=%d, pageIdx=%d, pageCnt=%d",
|
|
cntX, cntY, iconIdx, pageIndex, pageCount));
|
|
}
|
|
|
|
int newIndex = NOOP;
|
|
switch (keyCode) {
|
|
case KeyEvent.KEYCODE_DPAD_LEFT:
|
|
newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, -1 /*increment*/);
|
|
if (!isRtl && newIndex == NOOP && pageIndex > 0) {
|
|
newIndex = PREVIOUS_PAGE_RIGHT_COLUMN;
|
|
} else if (isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
|
|
newIndex = NEXT_PAGE_RIGHT_COLUMN;
|
|
}
|
|
break;
|
|
case KeyEvent.KEYCODE_DPAD_RIGHT:
|
|
newIndex = handleDpadHorizontal(iconIdx, cntX, cntY, map, 1 /*increment*/);
|
|
if (!isRtl && newIndex == NOOP && pageIndex < pageCount - 1) {
|
|
newIndex = NEXT_PAGE_LEFT_COLUMN;
|
|
} else if (isRtl && newIndex == NOOP && pageIndex > 0) {
|
|
newIndex = PREVIOUS_PAGE_LEFT_COLUMN;
|
|
}
|
|
break;
|
|
case KeyEvent.KEYCODE_DPAD_DOWN:
|
|
newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, 1 /*increment*/);
|
|
break;
|
|
case KeyEvent.KEYCODE_DPAD_UP:
|
|
newIndex = handleDpadVertical(iconIdx, cntX, cntY, map, -1 /*increment*/);
|
|
break;
|
|
case KeyEvent.KEYCODE_MOVE_HOME:
|
|
newIndex = handleMoveHome();
|
|
break;
|
|
case KeyEvent.KEYCODE_MOVE_END:
|
|
newIndex = handleMoveEnd();
|
|
break;
|
|
case KeyEvent.KEYCODE_PAGE_DOWN:
|
|
newIndex = handlePageDown(pageIndex, pageCount);
|
|
break;
|
|
case KeyEvent.KEYCODE_PAGE_UP:
|
|
newIndex = handlePageUp(pageIndex);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (DEBUG) {
|
|
Log.v(TAG, String.format("handleKeyEvent FINISH: index [%d -> %s]",
|
|
iconIdx, getStringIndex(newIndex)));
|
|
}
|
|
return newIndex;
|
|
}
|
|
|
|
/**
|
|
* Returns a matrix of size (m x n) that has been initialized with {@link #EMPTY}.
|
|
*
|
|
* @param m number of columns in the matrix
|
|
* @param n number of rows in the matrix
|
|
*/
|
|
// TODO: get rid of dynamic matrix creation.
|
|
private static int[][] createFullMatrix(int m, int n) {
|
|
int[][] matrix = new int [m][n];
|
|
|
|
for (int i=0; i < m;i++) {
|
|
Arrays.fill(matrix[i], EMPTY);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
/**
|
|
* Returns a matrix of size same as the {@link CellLayout} dimension that is initialized with the
|
|
* index of the child view.
|
|
*/
|
|
// TODO: get rid of the dynamic matrix creation
|
|
public static int[][] createSparseMatrix(CellLayout layout) {
|
|
ShortcutAndWidgetContainer parent = layout.getShortcutsAndWidgets();
|
|
final int m = layout.getCountX();
|
|
final int n = layout.getCountY();
|
|
final boolean invert = parent.invertLayoutHorizontally();
|
|
|
|
int[][] matrix = createFullMatrix(m, n);
|
|
|
|
// Iterate thru the children.
|
|
for (int i = 0; i < parent.getChildCount(); i++ ) {
|
|
View cell = parent.getChildAt(i);
|
|
if (!cell.isFocusable()) {
|
|
continue;
|
|
}
|
|
int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
|
|
int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
|
|
matrix[invert ? (m - cx - 1) : cx][cy] = i;
|
|
}
|
|
if (DEBUG) {
|
|
printMatrix(matrix);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
/**
|
|
* Creates a sparse matrix that merges the icon and hotseat view group using the cell layout.
|
|
* The size of the returning matrix is [icon column count x (icon + hotseat row count)]
|
|
* in portrait orientation. In landscape, [(icon + hotseat) column count x (icon row count)]
|
|
*/
|
|
// TODO: get rid of the dynamic matrix creation
|
|
public static int[][] createSparseMatrix(CellLayout iconLayout, CellLayout hotseatLayout,
|
|
boolean isHotseatHorizontal, int allappsiconRank) {
|
|
|
|
ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();
|
|
ViewGroup hotseatParent = hotseatLayout.getShortcutsAndWidgets();
|
|
|
|
boolean moreIconsInHotseatThanWorkspace = isHotseatHorizontal ?
|
|
hotseatLayout.getCountX() > iconLayout.getCountX() :
|
|
hotseatLayout.getCountY() > iconLayout.getCountY();
|
|
|
|
int m, n;
|
|
if (isHotseatHorizontal) {
|
|
m = hotseatLayout.getCountX();
|
|
n = iconLayout.getCountY() + hotseatLayout.getCountY();
|
|
} else {
|
|
m = iconLayout.getCountX() + hotseatLayout.getCountX();
|
|
n = hotseatLayout.getCountY();
|
|
}
|
|
int[][] matrix = createFullMatrix(m, n);
|
|
if (moreIconsInHotseatThanWorkspace) {
|
|
if (isHotseatHorizontal) {
|
|
for (int j = 0; j < n; j++) {
|
|
matrix[allappsiconRank][j] = ALL_APPS_COLUMN;
|
|
}
|
|
} else {
|
|
for (int j = 0; j < m; j++) {
|
|
matrix[j][allappsiconRank] = ALL_APPS_COLUMN;
|
|
}
|
|
}
|
|
}
|
|
// Iterate thru the children of the workspace.
|
|
for (int i = 0; i < iconParent.getChildCount(); i++) {
|
|
View cell = iconParent.getChildAt(i);
|
|
if (!cell.isFocusable()) {
|
|
continue;
|
|
}
|
|
int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
|
|
int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
|
|
if (moreIconsInHotseatThanWorkspace) {
|
|
if (isHotseatHorizontal && cx >= allappsiconRank) {
|
|
// Add 1 to account for the All Apps button.
|
|
cx++;
|
|
}
|
|
if (!isHotseatHorizontal && cy >= allappsiconRank) {
|
|
// Add 1 to account for the All Apps button.
|
|
cy++;
|
|
}
|
|
}
|
|
matrix[cx][cy] = i;
|
|
}
|
|
|
|
// Iterate thru the children of the hotseat.
|
|
for (int i = hotseatParent.getChildCount() - 1; i >= 0; i--) {
|
|
if (isHotseatHorizontal) {
|
|
int cx = ((CellLayout.LayoutParams)
|
|
hotseatParent.getChildAt(i).getLayoutParams()).cellX;
|
|
matrix[cx][iconLayout.getCountY()] = iconParent.getChildCount() + i;
|
|
} else {
|
|
int cy = ((CellLayout.LayoutParams)
|
|
hotseatParent.getChildAt(i).getLayoutParams()).cellY;
|
|
matrix[iconLayout.getCountX()][cy] = iconParent.getChildCount() + i;
|
|
}
|
|
}
|
|
if (DEBUG) {
|
|
printMatrix(matrix);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
/**
|
|
* Creates a sparse matrix that merges the icon of previous/next page and last column of
|
|
* current page. When left key is triggered on the leftmost column, sparse matrix is created
|
|
* that combines previous page matrix and an extra column on the right. Likewise, when right
|
|
* key is triggered on the rightmost column, sparse matrix is created that combines this column
|
|
* on the 0th column and the next page matrix.
|
|
*
|
|
* @param pivotX x coordinate of the focused item in the current page
|
|
* @param pivotY y coordinate of the focused item in the current page
|
|
*/
|
|
// TODO: get rid of the dynamic matrix creation
|
|
public static int[][] createSparseMatrix(CellLayout iconLayout, int pivotX, int pivotY) {
|
|
|
|
ViewGroup iconParent = iconLayout.getShortcutsAndWidgets();
|
|
|
|
int[][] matrix = createFullMatrix(iconLayout.getCountX() + 1, iconLayout.getCountY());
|
|
|
|
// Iterate thru the children of the top parent.
|
|
for (int i = 0; i < iconParent.getChildCount(); i++) {
|
|
View cell = iconParent.getChildAt(i);
|
|
if (!cell.isFocusable()) {
|
|
continue;
|
|
}
|
|
int cx = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellX;
|
|
int cy = ((CellLayout.LayoutParams) cell.getLayoutParams()).cellY;
|
|
if (pivotX < 0) {
|
|
matrix[cx - pivotX][cy] = i;
|
|
} else {
|
|
matrix[cx][cy] = i;
|
|
}
|
|
}
|
|
|
|
if (pivotX < 0) {
|
|
matrix[0][pivotY] = PIVOT;
|
|
} else {
|
|
matrix[pivotX][pivotY] = PIVOT;
|
|
}
|
|
if (DEBUG) {
|
|
printMatrix(matrix);
|
|
}
|
|
return matrix;
|
|
}
|
|
|
|
//
|
|
// key event handling methods.
|
|
//
|
|
|
|
/**
|
|
* Calculates icon that has is closest to the horizontal axis in reference to the cur icon.
|
|
*
|
|
* Example of the check order for KEYCODE_DPAD_RIGHT:
|
|
* [ ][ ][13][14][15]
|
|
* [ ][ 6][ 8][10][12]
|
|
* [ X][ 1][ 2][ 3][ 4]
|
|
* [ ][ 5][ 7][ 9][11]
|
|
*/
|
|
// TODO: add unit tests to verify all permutation.
|
|
private static int handleDpadHorizontal(int iconIdx, int cntX, int cntY,
|
|
int[][] matrix, int increment) {
|
|
if(matrix == null) {
|
|
throw new IllegalStateException("Dpad navigation requires a matrix.");
|
|
}
|
|
int newIconIndex = NOOP;
|
|
|
|
int xPos = -1;
|
|
int yPos = -1;
|
|
// Figure out the location of the icon.
|
|
for (int i = 0; i < cntX; i++) {
|
|
for (int j = 0; j < cntY; j++) {
|
|
if (matrix[i][j] == iconIdx) {
|
|
xPos = i;
|
|
yPos = j;
|
|
}
|
|
}
|
|
}
|
|
if (DEBUG) {
|
|
Log.v(TAG, String.format("\thandleDpadHorizontal: \t[x, y]=[%d, %d] iconIndex=%d",
|
|
xPos, yPos, iconIdx));
|
|
}
|
|
|
|
// Rule1: check first in the horizontal direction
|
|
for (int x = xPos + increment; 0 <= x && x < cntX; x += increment) {
|
|
if ((newIconIndex = inspectMatrix(x, yPos, cntX, cntY, matrix)) != NOOP
|
|
&& newIconIndex != ALL_APPS_COLUMN) {
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
|
|
// Rule2: check (x1-n, yPos + increment), (x1-n, yPos - increment)
|
|
// (x2-n, yPos + 2*increment), (x2-n, yPos - 2*increment)
|
|
int nextYPos1;
|
|
int nextYPos2;
|
|
int x = -1;
|
|
for (int coeff = 1; coeff < cntY; coeff++) {
|
|
nextYPos1 = yPos + coeff * increment;
|
|
nextYPos2 = yPos - coeff * increment;
|
|
x = xPos + increment * coeff;
|
|
if (inspectMatrix(x, nextYPos1, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
|
|
nextYPos1 += increment;
|
|
|
|
}
|
|
if (inspectMatrix(x, nextYPos2, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
|
|
nextYPos2 -= increment;
|
|
}
|
|
for (; 0 <= x && x < cntX; x += increment) {
|
|
if ((newIconIndex = inspectMatrix(x, nextYPos1, cntX, cntY, matrix)) != NOOP) {
|
|
return newIconIndex;
|
|
}
|
|
if ((newIconIndex = inspectMatrix(x, nextYPos2, cntX, cntY, matrix)) != NOOP) {
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Rule 3: if switching between pages, do a brute-force search to find an item that was
|
|
// missed by rules 1 and 2 (such as when going from a bottom right icon to top left)
|
|
if (iconIdx == PIVOT) {
|
|
for (x = xPos + increment; 0 <= x && x < cntX; x += increment) {
|
|
for (int y = 0; y < cntY; y++) {
|
|
if ((newIconIndex = inspectMatrix(x, y, cntX, cntY, matrix)) != NOOP
|
|
&& newIconIndex != ALL_APPS_COLUMN) {
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return newIconIndex;
|
|
}
|
|
|
|
/**
|
|
* Calculates icon that is closest to the vertical axis in reference to the current icon.
|
|
*
|
|
* Example of the check order for KEYCODE_DPAD_DOWN:
|
|
* [ ][ ][ ][ X][ ][ ][ ]
|
|
* [ ][ ][ 5][ 1][ 4][ ][ ]
|
|
* [ ][10][ 7][ 2][ 6][ 9][ ]
|
|
* [14][12][ 9][ 3][ 8][11][13]
|
|
*/
|
|
// TODO: add unit tests to verify all permutation.
|
|
private static int handleDpadVertical(int iconIndex, int cntX, int cntY,
|
|
int [][] matrix, int increment) {
|
|
int newIconIndex = NOOP;
|
|
if(matrix == null) {
|
|
throw new IllegalStateException("Dpad navigation requires a matrix.");
|
|
}
|
|
|
|
int xPos = -1;
|
|
int yPos = -1;
|
|
// Figure out the location of the icon.
|
|
for (int i = 0; i< cntX; i++) {
|
|
for (int j = 0; j < cntY; j++) {
|
|
if (matrix[i][j] == iconIndex) {
|
|
xPos = i;
|
|
yPos = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (DEBUG) {
|
|
Log.v(TAG, String.format("\thandleDpadVertical: \t[x, y]=[%d, %d] iconIndex=%d",
|
|
xPos, yPos, iconIndex));
|
|
}
|
|
|
|
// Rule1: check first in the dpad direction
|
|
for (int y = yPos + increment; 0 <= y && y <cntY && 0 <= y; y += increment) {
|
|
if ((newIconIndex = inspectMatrix(xPos, y, cntX, cntY, matrix)) != NOOP
|
|
&& newIconIndex != ALL_APPS_COLUMN) {
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
|
|
// Rule2: check (xPos + increment, y_(1-n)), (xPos - increment, y_(1-n))
|
|
// (xPos + 2*increment, y_(2-n))), (xPos - 2*increment, y_(2-n))
|
|
int nextXPos1;
|
|
int nextXPos2;
|
|
int y = -1;
|
|
for (int coeff = 1; coeff < cntX; coeff++) {
|
|
nextXPos1 = xPos + coeff * increment;
|
|
nextXPos2 = xPos - coeff * increment;
|
|
y = yPos + increment * coeff;
|
|
if (inspectMatrix(nextXPos1, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
|
|
nextXPos1 += increment;
|
|
|
|
}
|
|
if (inspectMatrix(nextXPos2, y, cntX, cntY, matrix) == ALL_APPS_COLUMN) {
|
|
nextXPos2 -= increment;
|
|
}
|
|
for (; 0 <= y && y < cntY; y = y + increment) {
|
|
if ((newIconIndex = inspectMatrix(nextXPos1, y, cntX, cntY, matrix)) != NOOP) {
|
|
return newIconIndex;
|
|
}
|
|
if ((newIconIndex = inspectMatrix(nextXPos2, y, cntX, cntY, matrix)) != NOOP) {
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
}
|
|
return newIconIndex;
|
|
}
|
|
|
|
private static int handleMoveHome() {
|
|
return CURRENT_PAGE_FIRST_ITEM;
|
|
}
|
|
|
|
private static int handleMoveEnd() {
|
|
return CURRENT_PAGE_LAST_ITEM;
|
|
}
|
|
|
|
private static int handlePageDown(int pageIndex, int pageCount) {
|
|
if (pageIndex < pageCount -1) {
|
|
return NEXT_PAGE_FIRST_ITEM;
|
|
}
|
|
return CURRENT_PAGE_LAST_ITEM;
|
|
}
|
|
|
|
private static int handlePageUp(int pageIndex) {
|
|
if (pageIndex > 0) {
|
|
return PREVIOUS_PAGE_FIRST_ITEM;
|
|
} else {
|
|
return CURRENT_PAGE_FIRST_ITEM;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Helper methods.
|
|
//
|
|
|
|
private static boolean isValid(int xPos, int yPos, int countX, int countY) {
|
|
return (0 <= xPos && xPos < countX && 0 <= yPos && yPos < countY);
|
|
}
|
|
|
|
private static int inspectMatrix(int x, int y, int cntX, int cntY, int[][] matrix) {
|
|
int newIconIndex = NOOP;
|
|
if (isValid(x, y, cntX, cntY)) {
|
|
if (matrix[x][y] != -1) {
|
|
newIconIndex = matrix[x][y];
|
|
if (DEBUG) {
|
|
Log.v(TAG, String.format("\t\tinspect: \t[x, y]=[%d, %d] %d",
|
|
x, y, matrix[x][y]));
|
|
}
|
|
return newIconIndex;
|
|
}
|
|
}
|
|
return newIconIndex;
|
|
}
|
|
|
|
/**
|
|
* Only used for debugging.
|
|
*/
|
|
private static String getStringIndex(int index) {
|
|
switch(index) {
|
|
case NOOP: return "NOOP";
|
|
case PREVIOUS_PAGE_FIRST_ITEM: return "PREVIOUS_PAGE_FIRST";
|
|
case PREVIOUS_PAGE_LAST_ITEM: return "PREVIOUS_PAGE_LAST";
|
|
case PREVIOUS_PAGE_RIGHT_COLUMN:return "PREVIOUS_PAGE_RIGHT_COLUMN";
|
|
case CURRENT_PAGE_FIRST_ITEM: return "CURRENT_PAGE_FIRST";
|
|
case CURRENT_PAGE_LAST_ITEM: return "CURRENT_PAGE_LAST";
|
|
case NEXT_PAGE_FIRST_ITEM: return "NEXT_PAGE_FIRST";
|
|
case NEXT_PAGE_LEFT_COLUMN: return "NEXT_PAGE_LEFT_COLUMN";
|
|
case ALL_APPS_COLUMN: return "ALL_APPS_COLUMN";
|
|
default:
|
|
return Integer.toString(index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Only used for debugging.
|
|
*/
|
|
private static void printMatrix(int[][] matrix) {
|
|
Log.v(TAG, "\tprintMap:");
|
|
int m = matrix.length;
|
|
int n = matrix[0].length;
|
|
|
|
for (int j=0; j < n; j++) {
|
|
String colY = "\t\t";
|
|
for (int i=0; i < m; i++) {
|
|
colY += String.format("%3d",matrix[i][j]);
|
|
}
|
|
Log.v(TAG, colY);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param edgeColumn the column of the new icon. either {@link #NEXT_PAGE_LEFT_COLUMN} or
|
|
* {@link #NEXT_PAGE_RIGHT_COLUMN}
|
|
* @return the view adjacent to {@param oldView} in the {@param nextPage} of the folder.
|
|
*/
|
|
public static View getAdjacentChildInNextFolderPage(
|
|
ShortcutAndWidgetContainer nextPage, View oldView, int edgeColumn) {
|
|
final int newRow = ((CellLayout.LayoutParams) oldView.getLayoutParams()).cellY;
|
|
|
|
int column = (edgeColumn == NEXT_PAGE_LEFT_COLUMN) ^ nextPage.invertLayoutHorizontally()
|
|
? 0 : (((CellLayout) nextPage.getParent()).getCountX() - 1);
|
|
|
|
for (; column >= 0; column--) {
|
|
for (int row = newRow; row >= 0; row--) {
|
|
View newView = nextPage.getChildAt(column, row);
|
|
if (newView != null) {
|
|
return newView;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|