Examples with CellAndSpan com.android.launcher3.util.CellAndSpan used on opensource projects

Example 1 with CellAndSpan

use of com.android.launcher3.util.CellAndSpan in project android_packages_apps_Launcher3 by crdroidandroid.

the class CellLayout method beginOrAdjustReorderPreviewAnimations.

// This method starts or changes the reorder preview animations
private void beginOrAdjustReorderPreviewAnimations(ItemConfiguration solution, View dragView, int mode) {
    int childCount = mShortcutsAndWidgets.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View child = mShortcutsAndWidgets.getChildAt(i);
        if (child == dragView)
            continue;
        CellAndSpan c = solution.map.get(child);
        boolean skip = mode == ReorderPreviewAnimation.MODE_HINT && solution.intersectingViews != null && !solution.intersectingViews.contains(child);
        LayoutParams lp = (LayoutParams) child.getLayoutParams();
        if (c != null && !skip && (child instanceof Reorderable)) {
            ReorderPreviewAnimation rha = new ReorderPreviewAnimation((Reorderable) child, mode, lp.cellX, lp.cellY, c.cellX, c.cellY, c.spanX, c.spanY);
            rha.animate();
        }
    }
}

Example 2 with CellAndSpan

use of com.android.launcher3.util.CellAndSpan in project android_packages_apps_Launcher3 by crdroidandroid.

the class CellLayout method addViewsToTempLocation.

private boolean addViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop, int[] direction, View dragView, ItemConfiguration currentState) {
    if (views.size() == 0)
        return true;
    boolean success = false;
    Rect boundingRect = new Rect();
    // We construct a rect which represents the entire group of views passed in
    currentState.getBoundingRectForViews(views, boundingRect);
    // Mark the occupied state as false for the group of views we want to move.
    for (View v : views) {
        CellAndSpan c = currentState.map.get(v);
        mTmpOccupied.markCells(c, false);
    }
    GridOccupancy blockOccupied = new GridOccupancy(boundingRect.width(), boundingRect.height());
    int top = boundingRect.top;
    int left = boundingRect.left;
    // for interlocking.
    for (View v : views) {
        CellAndSpan c = currentState.map.get(v);
        blockOccupied.markCells(c.cellX - left, c.cellY - top, c.spanX, c.spanY, true);
    }
    mTmpOccupied.markCells(rectOccupiedByPotentialDrop, true);
    findNearestArea(boundingRect.left, boundingRect.top, boundingRect.width(), boundingRect.height(), direction, mTmpOccupied.cells, blockOccupied.cells, mTempLocation);
    // If we successfuly found a location by pushing the block of views, we commit it
    if (mTempLocation[0] >= 0 && mTempLocation[1] >= 0) {
        int deltaX = mTempLocation[0] - boundingRect.left;
        int deltaY = mTempLocation[1] - boundingRect.top;
        for (View v : views) {
            CellAndSpan c = currentState.map.get(v);
            c.cellX += deltaX;
            c.cellY += deltaY;
        }
        success = true;
    }
    // In either case, we set the occupied array as marked for the location of the views
    for (View v : views) {
        CellAndSpan c = currentState.map.get(v);
        mTmpOccupied.markCells(c, true);
    }
    return success;
}

Example 3 with CellAndSpan

use of com.android.launcher3.util.CellAndSpan in project android_packages_apps_Launcher3 by crdroidandroid.

the class CellLayout method copyCurrentStateToSolution.

private void copyCurrentStateToSolution(ItemConfiguration solution, boolean temp) {
    int childCount = mShortcutsAndWidgets.getChildCount();
    for (int i = 0; i < childCount; i++) {
        View child = mShortcutsAndWidgets.getChildAt(i);
        LayoutParams lp = (LayoutParams) child.getLayoutParams();
        CellAndSpan c;
        if (temp) {
            c = new CellAndSpan(lp.tmpCellX, lp.tmpCellY, lp.cellHSpan, lp.cellVSpan);
        } else {
            c = new CellAndSpan(lp.cellX, lp.cellY, lp.cellHSpan, lp.cellVSpan);
        }
        solution.add(child, c);
    }
}

Example 4 with CellAndSpan

use of com.android.launcher3.util.CellAndSpan in project android_packages_apps_Launcher3 by crdroidandroid.

the class CellLayout method pushViewsToTempLocation.

private boolean pushViewsToTempLocation(ArrayList<View> views, Rect rectOccupiedByPotentialDrop, int[] direction, View dragView, ItemConfiguration currentState) {
    ViewCluster cluster = new ViewCluster(views, currentState);
    Rect clusterRect = cluster.getBoundingRect();
    int whichEdge;
    int pushDistance;
    boolean fail = false;
    // the cluster must be shifted.
    if (direction[0] < 0) {
        whichEdge = ViewCluster.LEFT;
        pushDistance = clusterRect.right - rectOccupiedByPotentialDrop.left;
    } else if (direction[0] > 0) {
        whichEdge = ViewCluster.RIGHT;
        pushDistance = rectOccupiedByPotentialDrop.right - clusterRect.left;
    } else if (direction[1] < 0) {
        whichEdge = ViewCluster.TOP;
        pushDistance = clusterRect.bottom - rectOccupiedByPotentialDrop.top;
    } else {
        whichEdge = ViewCluster.BOTTOM;
        pushDistance = rectOccupiedByPotentialDrop.bottom - clusterRect.top;
    }
    // Break early for invalid push distance.
    if (pushDistance <= 0) {
        return false;
    }
    // Mark the occupied state as false for the group of views we want to move.
    for (View v : views) {
        CellAndSpan c = currentState.map.get(v);
        mTmpOccupied.markCells(c, false);
    }
    // We save the current configuration -- if we fail to find a solution we will revert
    // to the initial state. The process of finding a solution modifies the configuration
    // in place, hence the need for revert in the failure case.
    currentState.save();
    // The pushing algorithm is simplified by considering the views in the order in which
    // they would be pushed by the cluster. For example, if the cluster is leading with its
    // left edge, we consider sort the views by their right edge, from right to left.
    cluster.sortConfigurationForEdgePush(whichEdge);
    while (pushDistance > 0 && !fail) {
        for (View v : currentState.sortedViews) {
            // cluster.
            if (!cluster.views.contains(v) && v != dragView) {
                if (cluster.isViewTouchingEdge(v, whichEdge)) {
                    LayoutParams lp = (LayoutParams) v.getLayoutParams();
                    if (!lp.canReorder) {
                        // The push solution includes the all apps button, this is not viable.
                        fail = true;
                        break;
                    }
                    cluster.addView(v);
                    CellAndSpan c = currentState.map.get(v);
                    // Adding view to cluster, mark it as not occupied.
                    mTmpOccupied.markCells(c, false);
                }
            }
        }
        pushDistance--;
        // The cluster has been completed, now we move the whole thing over in the appropriate
        // direction.
        cluster.shift(whichEdge, 1);
    }
    boolean foundSolution = false;
    clusterRect = cluster.getBoundingRect();
    // is to ensure that completed shifted cluster lies completely within the cell layout.
    if (!fail && clusterRect.left >= 0 && clusterRect.right <= mCountX && clusterRect.top >= 0 && clusterRect.bottom <= mCountY) {
        foundSolution = true;
    } else {
        currentState.restore();
    }
    // In either case, we set the occupied array as marked for the location of the views
    for (View v : cluster.views) {
        CellAndSpan c = currentState.map.get(v);
        mTmpOccupied.markCells(c, true);
    }
    return foundSolution;
}

Example 5 with CellAndSpan

use of com.android.launcher3.util.CellAndSpan in project android_packages_apps_Launcher3 by crdroidandroid.

the class CellLayout method rearrangementExists.

private boolean rearrangementExists(int cellX, int cellY, int spanX, int spanY, int[] direction, View ignoreView, ItemConfiguration solution) {
    // Return early if get invalid cell positions
    if (cellX < 0 || cellY < 0)
        return false;
    mIntersectingViews.clear();
    mOccupiedRect.set(cellX, cellY, cellX + spanX, cellY + spanY);
    // Mark the desired location of the view currently being dragged.
    if (ignoreView != null) {
        CellAndSpan c = solution.map.get(ignoreView);
        if (c != null) {
            c.cellX = cellX;
            c.cellY = cellY;
        }
    }
    Rect r0 = new Rect(cellX, cellY, cellX + spanX, cellY + spanY);
    Rect r1 = new Rect();
    for (View child : solution.map.keySet()) {
        if (child == ignoreView)
            continue;
        CellAndSpan c = solution.map.get(child);
        LayoutParams lp = (LayoutParams) child.getLayoutParams();
        r1.set(c.cellX, c.cellY, c.cellX + c.spanX, c.cellY + c.spanY);
        if (Rect.intersects(r0, r1)) {
            if (!lp.canReorder) {
                return false;
            }
            mIntersectingViews.add(child);
        }
    }
    solution.intersectingViews = new ArrayList<>(mIntersectingViews);
    // without also displacing that item.
    if (attemptPushInDirection(mIntersectingViews, mOccupiedRect, direction, ignoreView, solution)) {
        return true;
    }
    // Next we try moving the views as a block, but without requiring the push mechanic.
    if (addViewsToTempLocation(mIntersectingViews, mOccupiedRect, direction, ignoreView, solution)) {
        return true;
    }
    // Ok, they couldn't move as a block, let's move them individually
    for (View v : mIntersectingViews) {
        if (!addViewToTempLocation(v, mOccupiedRect, direction, solution)) {
            return false;
        }
    }
    return true;
}