| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package android.support.v17.leanback.widget; |
| |
| /** |
| * A default implementation of {@link StaggeredGrid}. |
| * |
| * This implementation tries to fill items in consecutive row order. The next |
| * item is always in same row or in the next row. |
| */ |
| final class StaggeredGridDefault extends StaggeredGrid { |
| |
| @Override |
| protected int updateFirstVisibleOffset(int prependedItemSize) { |
| Location firstVisible = getLocation(mFirstVisibleIndex); |
| // Find a cached item in same row, if not found, just use last item. |
| int index = mFirstVisibleIndex - 1; |
| boolean foundCachedItemInSameRow = false; |
| while (index >= mFirstIndex) { |
| Location loc = getLocation(index); |
| if (loc.row == firstVisible.row) { |
| foundCachedItemInSameRow = true; |
| break; |
| } |
| index--; |
| } |
| if (!foundCachedItemInSameRow) { |
| index = mFirstVisibleIndex - 1; |
| } |
| // Assuming mFirstVisibleIndex is next to index on the same row, so the |
| // sum of offset of [index + 1, mFirstVisibleIndex] should be size of the item |
| // plus margin. |
| int offset = isReversedFlow() ? -getLocation(index).size - mMargin: |
| getLocation(index).size + mMargin; |
| for (int i = index + 1; i < mFirstVisibleIndex; i++) { |
| offset -= getLocation(index).offset; |
| } |
| firstVisible.offset = offset; |
| return offset; |
| } |
| |
| /** |
| * Returns the max edge value of item (visible or cached) in a row. This |
| * will be the place to append or prepend item not in cache. |
| */ |
| int getRowMax(int rowIndex) { |
| if (mFirstVisibleIndex < 0) { |
| return Integer.MIN_VALUE; |
| } |
| if (mReversedFlow) { |
| int edge = mProvider.getEdge(mFirstVisibleIndex); |
| if (getLocation(mFirstVisibleIndex).row == rowIndex) { |
| return edge; |
| } |
| for (int i = mFirstVisibleIndex + 1; i <= getLastIndex(); i++) { |
| Location loc = getLocation(i); |
| edge += loc.offset; |
| if (loc.row == rowIndex) { |
| return edge; |
| } |
| } |
| } else { |
| int edge = mProvider.getEdge(mLastVisibleIndex); |
| Location loc = getLocation(mLastVisibleIndex); |
| if (loc.row == rowIndex) { |
| return edge + loc.size; |
| } |
| for (int i = mLastVisibleIndex - 1; i >= getFirstIndex(); i--) { |
| edge -= loc.offset; |
| loc = getLocation(i); |
| if (loc.row == rowIndex) { |
| return edge + loc.size; |
| } |
| } |
| } |
| return Integer.MIN_VALUE; |
| } |
| |
| /** |
| * Returns the min edge value of item (visible or cached) in a row. This |
| * will be the place to prepend or append item not in cache. |
| */ |
| int getRowMin(int rowIndex) { |
| if (mFirstVisibleIndex < 0) { |
| return Integer.MAX_VALUE; |
| } |
| if (mReversedFlow) { |
| int edge = mProvider.getEdge(mLastVisibleIndex); |
| Location loc = getLocation(mLastVisibleIndex); |
| if (loc.row == rowIndex) { |
| return edge - loc.size; |
| } |
| for (int i = mLastVisibleIndex - 1; i >= getFirstIndex(); i--) { |
| edge -= loc.offset; |
| loc = getLocation(i); |
| if (loc.row == rowIndex) { |
| return edge - loc.size; |
| } |
| } |
| } else { |
| int edge = mProvider.getEdge(mFirstVisibleIndex); |
| if (getLocation(mFirstVisibleIndex).row == rowIndex) { |
| return edge; |
| } |
| for (int i = mFirstVisibleIndex + 1; i <= getLastIndex() ; i++) { |
| Location loc = getLocation(i); |
| edge += loc.offset; |
| if (loc.row == rowIndex) { |
| return edge; |
| } |
| } |
| } |
| return Integer.MAX_VALUE; |
| } |
| |
| /** |
| * Note this method has assumption that item is filled either in the same row |
| * next row of last item. Search until row index wrapped. |
| */ |
| @Override |
| public int findRowMax(boolean findLarge, int indexLimit, int[] indices) { |
| int value; |
| int edge = mProvider.getEdge(indexLimit); |
| Location loc = getLocation(indexLimit); |
| int row = loc.row; |
| int index = indexLimit; |
| int visitedRows = 1; |
| int visitRow = row; |
| if (mReversedFlow) { |
| value = edge; |
| for (int i = indexLimit + 1; visitedRows < mNumRows && i <= mLastVisibleIndex; i++) { |
| loc = getLocation(i); |
| edge += loc.offset; |
| if (loc.row != visitRow) { |
| visitRow = loc.row; |
| visitedRows++; |
| if (findLarge ? edge > value : edge < value) { |
| row = visitRow; |
| value = edge; |
| index = i; |
| } |
| } |
| } |
| } else { |
| value = edge + mProvider.getSize(indexLimit); |
| for (int i = indexLimit - 1; visitedRows < mNumRows && i >= mFirstVisibleIndex; i--) { |
| edge -= loc.offset; |
| loc = getLocation(i); |
| if (loc.row != visitRow) { |
| visitRow = loc.row; |
| visitedRows++; |
| int newValue = edge + mProvider.getSize(i); |
| if (findLarge ? newValue > value : newValue < value) { |
| row = visitRow; |
| value = newValue; |
| index = i; |
| } |
| } |
| } |
| } |
| if (indices != null) { |
| indices[0] = row; |
| indices[1] = index; |
| } |
| return value; |
| } |
| |
| /** |
| * Note this method has assumption that item is filled either in the same row |
| * next row of last item. Search until row index wrapped. |
| */ |
| @Override |
| public int findRowMin(boolean findLarge, int indexLimit, int[] indices) { |
| int value; |
| int edge = mProvider.getEdge(indexLimit); |
| Location loc = getLocation(indexLimit); |
| int row = loc.row; |
| int index = indexLimit; |
| int visitedRows = 1; |
| int visitRow = row; |
| if (mReversedFlow) { |
| value = edge - mProvider.getSize(indexLimit); |
| for (int i = indexLimit - 1; visitedRows < mNumRows && i >= mFirstVisibleIndex; i--) { |
| edge -= loc.offset; |
| loc = getLocation(i); |
| if (loc.row != visitRow) { |
| visitRow = loc.row; |
| visitedRows++; |
| int newValue = edge - mProvider.getSize(i); |
| if (findLarge ? newValue > value : newValue < value) { |
| value = newValue; |
| row = visitRow; |
| index = i; |
| } |
| } |
| } |
| } else { |
| value = edge; |
| for (int i = indexLimit + 1; visitedRows < mNumRows && i <= mLastVisibleIndex; i++) { |
| loc = getLocation(i); |
| edge += loc.offset; |
| if (loc.row != visitRow) { |
| visitRow = loc.row; |
| visitedRows++; |
| if (findLarge ? edge > value : edge < value) { |
| value = edge; |
| row = visitRow; |
| index = i; |
| } |
| } |
| } |
| } |
| if (indices != null) { |
| indices[0] = row; |
| indices[1] = index; |
| } |
| return value; |
| } |
| |
| private int findRowEdgeLimitSearchIndex(boolean append) { |
| boolean wrapped = false; |
| if (append) { |
| for (int index = mLastVisibleIndex; index >= mFirstVisibleIndex; index--) { |
| int row = getLocation(index).row; |
| if (row == 0) { |
| wrapped = true; |
| } else if (wrapped && row == mNumRows - 1) { |
| return index; |
| } |
| } |
| } else { |
| for (int index = mFirstVisibleIndex; index <= mLastVisibleIndex; index++) { |
| int row = getLocation(index).row; |
| if (row == mNumRows - 1) { |
| wrapped = true; |
| } else if (wrapped && row == 0) { |
| return index; |
| } |
| } |
| } |
| return -1; |
| } |
| |
| @Override |
| protected boolean appendVisibleItemsWithoutCache(int toLimit, boolean oneColumnMode) { |
| final int count = mProvider.getCount(); |
| int itemIndex; |
| int rowIndex; |
| int edgeLimit; |
| boolean edgeLimitIsValid; |
| if (mLastVisibleIndex >= 0) { |
| if (mLastVisibleIndex < getLastIndex()) { |
| // should fill using cache instead |
| return false; |
| } |
| itemIndex = mLastVisibleIndex + 1; |
| rowIndex = getLocation(mLastVisibleIndex).row; |
| // find start item index of "previous column" |
| int edgeLimitSearchIndex = findRowEdgeLimitSearchIndex(true); |
| if (edgeLimitSearchIndex < 0) { |
| // if "previous colummn" is not found, using edgeLimit of |
| // first row currently in grid |
| edgeLimit = Integer.MIN_VALUE; |
| for (int i = 0; i < mNumRows; i++) { |
| edgeLimit = mReversedFlow ? getRowMin(i) : getRowMax(i); |
| if (edgeLimit != Integer.MIN_VALUE) { |
| break; |
| } |
| } |
| } else { |
| edgeLimit = mReversedFlow ? findRowMin(false, edgeLimitSearchIndex, null) : |
| findRowMax(true, edgeLimitSearchIndex, null); |
| } |
| if (mReversedFlow ? getRowMin(rowIndex) <= edgeLimit |
| : getRowMax(rowIndex) >= edgeLimit) { |
| // if current row exceeds previous column, fill from next row |
| rowIndex = rowIndex + 1; |
| if (rowIndex == mNumRows) { |
| // start a new column and using edge limit of current column |
| rowIndex = 0; |
| edgeLimit = mReversedFlow ? findRowMin(false, null) : findRowMax(true, null); |
| } |
| } |
| edgeLimitIsValid = true; |
| } else { |
| itemIndex = mStartIndex != START_DEFAULT ? mStartIndex : 0; |
| rowIndex = itemIndex % mNumRows; |
| edgeLimit = 0; |
| edgeLimitIsValid = false; |
| } |
| |
| boolean filledOne = false; |
| while (true) { |
| // find end-most row edge (.high is biggest, or .low is smallest in reversed flow) |
| // fill from current row till last row so that each row will grow longer than |
| // the previous highest row. |
| for (; rowIndex < mNumRows; rowIndex++) { |
| // fill one item to a row |
| if (itemIndex == count || (!oneColumnMode && checkAppendOverLimit(toLimit))) { |
| return filledOne; |
| } |
| int location = mReversedFlow ? getRowMin(rowIndex) : getRowMax(rowIndex); |
| if (location == Integer.MAX_VALUE || location == Integer.MIN_VALUE) { |
| // nothing on the row |
| if (rowIndex == 0) { |
| location = mReversedFlow ? getRowMin(mNumRows - 1) : getRowMax(mNumRows - 1); |
| if (location != Integer.MAX_VALUE && location != Integer.MIN_VALUE) { |
| location = location + (mReversedFlow ? -mMargin : mMargin); |
| } |
| } else { |
| location = mReversedFlow ? getRowMax(rowIndex - 1) : getRowMin(rowIndex - 1); |
| } |
| } else { |
| location = location + (mReversedFlow ? -mMargin : mMargin); |
| } |
| int size = appendVisibleItemToRow(itemIndex++, rowIndex, location); |
| filledOne = true; |
| // fill more item to the row to make sure this row is longer than |
| // the previous highest row. |
| if (edgeLimitIsValid) { |
| while (mReversedFlow ? location - size > edgeLimit : |
| location + size < edgeLimit) { |
| if (itemIndex == count || (!oneColumnMode && checkAppendOverLimit(toLimit))) { |
| return filledOne; |
| } |
| location = location + (mReversedFlow ? - size - mMargin : size + mMargin); |
| size = appendVisibleItemToRow(itemIndex++, rowIndex, location); |
| } |
| } else { |
| edgeLimitIsValid = true; |
| edgeLimit = mReversedFlow ? getRowMin(rowIndex) : getRowMax(rowIndex); |
| } |
| } |
| if (oneColumnMode) { |
| return filledOne; |
| } |
| edgeLimit = mReversedFlow ? findRowMin(false, null) : findRowMax(true, null); |
| // start fill from row 0 again |
| rowIndex = 0; |
| } |
| } |
| |
| @Override |
| protected boolean prependVisibleItemsWithoutCache(int toLimit, boolean oneColumnMode) { |
| int itemIndex; |
| int rowIndex; |
| int edgeLimit; |
| boolean edgeLimitIsValid; |
| if (mFirstVisibleIndex >= 0) { |
| if (mFirstVisibleIndex > getFirstIndex()) { |
| // should fill using cache instead |
| return false; |
| } |
| itemIndex = mFirstVisibleIndex - 1; |
| rowIndex = getLocation(mFirstVisibleIndex).row; |
| // find start item index of "previous column" |
| int edgeLimitSearchIndex = findRowEdgeLimitSearchIndex(false); |
| if (edgeLimitSearchIndex < 0) { |
| // if "previous colummn" is not found, using edgeLimit of |
| // last row currently in grid and fill from upper row |
| rowIndex = rowIndex - 1; |
| edgeLimit = Integer.MAX_VALUE; |
| for (int i = mNumRows - 1; i >= 0; i--) { |
| edgeLimit = mReversedFlow ? getRowMax(i) : getRowMin(i); |
| if (edgeLimit != Integer.MAX_VALUE) { |
| break; |
| } |
| } |
| } else { |
| edgeLimit = mReversedFlow ? findRowMax(true, edgeLimitSearchIndex, null) : |
| findRowMin(false, edgeLimitSearchIndex, null); |
| } |
| if (mReversedFlow ? getRowMax(rowIndex) >= edgeLimit |
| : getRowMin(rowIndex) <= edgeLimit) { |
| // if current row exceeds previous column, fill from next row |
| rowIndex = rowIndex - 1; |
| if (rowIndex < 0) { |
| // start a new column and using edge limit of current column |
| rowIndex = mNumRows - 1; |
| edgeLimit = mReversedFlow ? findRowMax(true, null) : |
| findRowMin(false, null); |
| } |
| } |
| edgeLimitIsValid = true; |
| } else { |
| itemIndex = mStartIndex != START_DEFAULT ? mStartIndex : 0; |
| rowIndex = itemIndex % mNumRows; |
| edgeLimit = 0; |
| edgeLimitIsValid = false; |
| } |
| boolean filledOne = false; |
| while (true) { |
| // find start-most row edge (.low is smallest, or .high is largest in reversed flow) |
| // fill from current row till first row so that each row will grow longer than |
| // the previous lowest row. |
| for (; rowIndex >= 0; rowIndex--) { |
| // fill one item to a row |
| if (itemIndex < 0 || (!oneColumnMode && checkPrependOverLimit(toLimit))) { |
| return filledOne; |
| } |
| int location = mReversedFlow ? getRowMax(rowIndex) : getRowMin(rowIndex); |
| if (location == Integer.MAX_VALUE || location == Integer.MIN_VALUE) { |
| // nothing on the row |
| if (rowIndex == mNumRows - 1) { |
| location = mReversedFlow ? getRowMax(0) : getRowMin(0); |
| if (location != Integer.MAX_VALUE && location != Integer.MIN_VALUE) { |
| location = location + (mReversedFlow ? mMargin : -mMargin); |
| } |
| } else { |
| location = mReversedFlow ? getRowMin(rowIndex + 1) : getRowMax(rowIndex + 1); |
| } |
| } else { |
| location = location + (mReversedFlow ? mMargin : -mMargin); |
| } |
| int size = prependVisibleItemToRow(itemIndex--, rowIndex, location); |
| filledOne = true; |
| |
| // fill more item to the row to make sure this row is longer than |
| // the previous highest row. |
| if (edgeLimitIsValid) { |
| while (mReversedFlow ? location + size < edgeLimit : |
| location - size > edgeLimit) { |
| if (itemIndex < 0 || (!oneColumnMode && checkPrependOverLimit(toLimit))) { |
| return filledOne; |
| } |
| location = location + (mReversedFlow ? size + mMargin : -size - mMargin); |
| size = prependVisibleItemToRow(itemIndex--, rowIndex, location); |
| } |
| } else { |
| edgeLimitIsValid = true; |
| edgeLimit = mReversedFlow ? getRowMax(rowIndex) : getRowMin(rowIndex); |
| } |
| } |
| if (oneColumnMode) { |
| return filledOne; |
| } |
| edgeLimit = mReversedFlow ? findRowMax(true, null) : findRowMin(false, null); |
| // start fill from last row again |
| rowIndex = mNumRows - 1; |
| } |
| } |
| |
| |
| } |
