Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d3ea06ce authored by Jeremy Sim's avatar Jeremy Sim
Browse files

Rename isHorizontalDivision to isLeftRightSplit (and flip boolean logic) 

Just renaming the variable name `isHorizontalDivision` to the new naming convention we've settled on: `isLeftRightSplit`. (I keep getting confused by `isHorizontalDivision`.) This requires a boolean logic flip as well.

Bug: 349828130
Test: Everything still works
Flag: EXEMPT refactor
Change-Id: I7a0bfd6bc8d1b285313349b3095feff00627e832
parent 7a1f0e47

libs/WindowManager/Shell/src/com/android/wm/shell/common/split/DividerSnapAlgorithm.java

+41 −41
Original line number Diff line number Diff line
@@ -87,7 +87,7 @@ public class DividerSnapAlgorithm { 
    private final boolean mCalculateRatiosBasedOnAvailableSpace;

    /** Allows split ratios that go offscreen (a.k.a. "flexible split") */

    private final boolean mAllowOffscreenRatios;

    private final boolean mIsHorizontalDivision;

    private final boolean mIsLeftRightSplit;



    /** The first target which is still splitting the screen */

    private final SnapTarget mFirstSplitTarget;
@@ -101,13 +101,13 @@ public class DividerSnapAlgorithm { 




    public DividerSnapAlgorithm(Resources res, int displayWidth, int displayHeight, int dividerSize,

        boolean isHorizontalDivision, Rect insets, int dockSide) {

        this(res, displayWidth, displayHeight, dividerSize, isHorizontalDivision, insets,

            boolean isLeftRightSplit, Rect insets, int dockSide) {

        this(res, displayWidth, displayHeight, dividerSize, isLeftRightSplit, insets,

                dockSide, false /* minimized */, true /* resizable */);

    }



    public DividerSnapAlgorithm(Resources res, int displayWidth, int displayHeight, int dividerSize,

            boolean isHorizontalDivision, Rect insets, int dockSide, boolean isMinimizedMode,

            boolean isLeftRightSplit, Rect insets, int dockSide, boolean isMinimizedMode,

            boolean isHomeResizable) {

        mMinFlingVelocityPxPerSecond =

                MIN_FLING_VELOCITY_DP_PER_SECOND * res.getDisplayMetrics().density;
@@ -116,7 +116,7 @@ public class DividerSnapAlgorithm { 
        mDividerSize = dividerSize;

        mDisplayWidth = displayWidth;

        mDisplayHeight = displayHeight;

        mIsHorizontalDivision = isHorizontalDivision;

        mIsLeftRightSplit = isLeftRightSplit;

        mInsets.set(insets);

        mSnapMode = isMinimizedMode ? SNAP_MODE_MINIMIZED :

                res.getInteger(com.android.internal.R.integer.config_dockedStackDividerSnapMode);
@@ -133,7 +133,7 @@ public class DividerSnapAlgorithm { 
                Flags.enableFlexibleTwoAppSplit() && SplitScreenUtils.allowOffscreenRatios(res);

        mTaskHeightInMinimizedMode = isHomeResizable ? res.getDimensionPixelSize(

                com.android.internal.R.dimen.task_height_of_minimized_mode) : 0;

        calculateTargets(isHorizontalDivision, dockSide);

        calculateTargets(isLeftRightSplit, dockSide);

        mFirstSplitTarget = mTargets.get(1);

        mLastSplitTarget = mTargets.get(mTargets.size() - 2);

        mDismissStartTarget = mTargets.get(0);
@@ -218,18 +218,18 @@ public class DividerSnapAlgorithm { 
    }



    private int getStartInset() {

        if (mIsHorizontalDivision) {

            return mInsets.top;

        } else {

        if (mIsLeftRightSplit) {

            return mInsets.left;

        } else {

            return mInsets.top;

        }

    }



    private int getEndInset() {

        if (mIsHorizontalDivision) {

            return mInsets.bottom;

        } else {

        if (mIsLeftRightSplit) {

            return mInsets.right;

        } else {

            return mInsets.bottom;

        }

    }
@@ -269,11 +269,11 @@ public class DividerSnapAlgorithm { 
        return mTargets.get(minIndex);

    }



    private void calculateTargets(boolean isHorizontalDivision, int dockedSide) {

    private void calculateTargets(boolean isLeftRightSplit, int dockedSide) {

        mTargets.clear();

        int dividerMax = isHorizontalDivision

                ? mDisplayHeight

                : mDisplayWidth;

        int dividerMax = isLeftRightSplit

                ? mDisplayWidth

                : mDisplayHeight;

        int startPos = -mDividerSize;

        if (dockedSide == DOCKED_RIGHT) {

            startPos += mInsets.left;
@@ -281,38 +281,38 @@ public class DividerSnapAlgorithm { 
        mTargets.add(new SnapTarget(startPos, SNAP_TO_START_AND_DISMISS, 0.35f));

        switch (mSnapMode) {

            case SNAP_MODE_16_9:

                addRatio16_9Targets(isHorizontalDivision, dividerMax);

                addRatio16_9Targets(isLeftRightSplit, dividerMax);

                break;

            case SNAP_FIXED_RATIO:

                addFixedDivisionTargets(isHorizontalDivision, dividerMax);

                addFixedDivisionTargets(isLeftRightSplit, dividerMax);

                break;

            case SNAP_ONLY_1_1:

                addMiddleTarget(isHorizontalDivision);

                addMiddleTarget(isLeftRightSplit);

                break;

            case SNAP_MODE_MINIMIZED:

                addMinimizedTarget(isHorizontalDivision, dockedSide);

                addMinimizedTarget(isLeftRightSplit, dockedSide);

                break;

        }

        mTargets.add(new SnapTarget(dividerMax, SNAP_TO_END_AND_DISMISS, 0.35f));

    }



    private void addNonDismissingTargets(boolean isHorizontalDivision, int topPosition,

    private void addNonDismissingTargets(boolean isLeftRightSplit, int topPosition,

            int bottomPosition, int dividerMax) {

        @PersistentSnapPosition int firstTarget =

                mAllowOffscreenRatios ? SNAP_TO_2_10_90 : SNAP_TO_2_33_66;

        @PersistentSnapPosition int lastTarget =

                mAllowOffscreenRatios ? SNAP_TO_2_90_10 : SNAP_TO_2_66_33;

        maybeAddTarget(topPosition, topPosition - getStartInset(), firstTarget);

        addMiddleTarget(isHorizontalDivision);

        addMiddleTarget(isLeftRightSplit);

        maybeAddTarget(bottomPosition,

                dividerMax - getEndInset() - (bottomPosition + mDividerSize), lastTarget);

    }



    private void addFixedDivisionTargets(boolean isHorizontalDivision, int dividerMax) {

        int start = isHorizontalDivision ? mInsets.top : mInsets.left;

        int end = isHorizontalDivision

                ? mDisplayHeight - mInsets.bottom

                : mDisplayWidth - mInsets.right;

    private void addFixedDivisionTargets(boolean isLeftRightSplit, int dividerMax) {

        int start = isLeftRightSplit ? mInsets.left : mInsets.top;

        int end = isLeftRightSplit

                ? mDisplayWidth - mInsets.right

                : mDisplayHeight - mInsets.bottom;

        int size = (int) (mFixedRatio * (end - start)) - mDividerSize / 2;



        if (mAllowOffscreenRatios) {
@@ -323,23 +323,23 @@ public class DividerSnapAlgorithm { 
        }

        int topPosition = start + size;

        int bottomPosition = end - size - mDividerSize;

        addNonDismissingTargets(isHorizontalDivision, topPosition, bottomPosition, dividerMax);

        addNonDismissingTargets(isLeftRightSplit, topPosition, bottomPosition, dividerMax);

    }



    private void addRatio16_9Targets(boolean isHorizontalDivision, int dividerMax) {

        int start = isHorizontalDivision ? mInsets.top : mInsets.left;

        int end = isHorizontalDivision

                ? mDisplayHeight - mInsets.bottom

                : mDisplayWidth - mInsets.right;

        int startOther = isHorizontalDivision ? mInsets.left : mInsets.top;

        int endOther = isHorizontalDivision

    private void addRatio16_9Targets(boolean isLeftRightSplit, int dividerMax) {

        int start = isLeftRightSplit ? mInsets.left : mInsets.top;

        int end = isLeftRightSplit

                ? mDisplayWidth - mInsets.right

                : mDisplayHeight - mInsets.bottom;

        int startOther = isLeftRightSplit ? mInsets.top : mInsets.left;

        int endOther = isLeftRightSplit

                ? mDisplayHeight - mInsets.bottom

                : mDisplayWidth - mInsets.right;

        float size = 9.0f / 16.0f * (endOther - startOther);

        int sizeInt = (int) Math.floor(size);

        int topPosition = start + sizeInt;

        int bottomPosition = end - sizeInt - mDividerSize;

        addNonDismissingTargets(isHorizontalDivision, topPosition, bottomPosition, dividerMax);

        addNonDismissingTargets(isLeftRightSplit, topPosition, bottomPosition, dividerMax);

    }



    /**
@@ -352,17 +352,17 @@ public class DividerSnapAlgorithm { 
        }

    }



    private void addMiddleTarget(boolean isHorizontalDivision) {

        int position = DockedDividerUtils.calculateMiddlePosition(isHorizontalDivision,

    private void addMiddleTarget(boolean isLeftRightSplit) {

        int position = DockedDividerUtils.calculateMiddlePosition(isLeftRightSplit,

                mInsets, mDisplayWidth, mDisplayHeight, mDividerSize);

        mTargets.add(new SnapTarget(position, SNAP_TO_2_50_50));

    }



    private void addMinimizedTarget(boolean isHorizontalDivision, int dockedSide) {

    private void addMinimizedTarget(boolean isLeftRightSplit, int dockedSide) {

        // In portrait offset the position by the statusbar height, in landscape add the statusbar

        // height as well to match portrait offset

        int position = mTaskHeightInMinimizedMode + mInsets.top;

        if (!isHorizontalDivision) {

        if (isLeftRightSplit) {

            if (dockedSide == DOCKED_LEFT) {

                position += mInsets.left;

            } else if (dockedSide == DOCKED_RIGHT) {

libs/WindowManager/Shell/src/com/android/wm/shell/common/split/DockedDividerUtils.java

+5 −5
Original line number Diff line number Diff line
@@ -97,12 +97,12 @@ public class DockedDividerUtils { 
        }

    }



    public static int calculateMiddlePosition(boolean isHorizontalDivision, Rect insets,

    public static int calculateMiddlePosition(boolean isLeftRightSplit, Rect insets,

            int displayWidth, int displayHeight, int dividerSize) {

        int start = isHorizontalDivision ? insets.top : insets.left;

        int end = isHorizontalDivision

                ? displayHeight - insets.bottom

                : displayWidth - insets.right;

        int start = isLeftRightSplit ? insets.left : insets.top;

        int end = isLeftRightSplit

                ? displayWidth - insets.right

                : displayHeight - insets.bottom;

        return start + (end - start) / 2 - dividerSize / 2;

    }

libs/WindowManager/Shell/src/com/android/wm/shell/common/split/SplitLayout.java

+1 −1
Original line number Diff line number Diff line
@@ -665,7 +665,7 @@ public final class SplitLayout implements DisplayInsetsController.OnInsetsChange 
                rootBounds.width(),

                rootBounds.height(),

                mDividerSize,

                !mIsLeftRightSplit,

                mIsLeftRightSplit,

                insets,

                mIsLeftRightSplit ? DOCKED_LEFT : DOCKED_TOP /* dockSide */);

    }