Examples with InsettableFrameLayout com.android.launcher3.InsettableFrameLayout used on opensource projects

Example 1 with InsettableFrameLayout

use of com.android.launcher3.InsettableFrameLayout in project android_packages_apps_Launcher3 by crdroidandroid.

the class ArrowPopup method orientAboutObject.

/**
 * @see #orientAboutObject()
 *
 * @param allowAlignLeft Set to false if we already tried aligning left and didn't have room.
 * @param allowAlignRight Set to false if we already tried aligning right and didn't have room.
 * TODO: Can we test this with all permutations of widths/heights and icon locations + RTL?
 */
private void orientAboutObject(boolean allowAlignLeft, boolean allowAlignRight) {
    measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int extraVerticalSpace = mArrowHeight + mArrowOffsetVertical + getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
    // The margins are added after we call this method, so we need to account for them here.
    int numVisibleChildren = 0;
    for (int i = getChildCount() - 1; i >= 0; --i) {
        if (getChildAt(i).getVisibility() == VISIBLE) {
            numVisibleChildren++;
        }
    }
    int childMargins = (numVisibleChildren - 1) * mMargin;
    int height = getMeasuredHeight() + extraVerticalSpace + childMargins;
    int width = getMeasuredWidth() + getPaddingLeft() + getPaddingRight();
    getTargetObjectLocation(mTempRect);
    InsettableFrameLayout dragLayer = getPopupContainer();
    Rect insets = dragLayer.getInsets();
    // Align left (right in RTL) if there is room.
    int leftAlignedX = mTempRect.left;
    int rightAlignedX = mTempRect.right - width;
    mIsLeftAligned = !mIsRtl ? allowAlignLeft : !allowAlignRight;
    int x = mIsLeftAligned ? leftAlignedX : rightAlignedX;
    // Offset x so that the arrow and shortcut icons are center-aligned with the original icon.
    int iconWidth = mTempRect.width();
    int xOffset = iconWidth / 2 - mArrowOffsetHorizontal - mArrowWidth / 2;
    x += mIsLeftAligned ? xOffset : -xOffset;
    // Check whether we can still align as we originally wanted, now that we've calculated x.
    if (!allowAlignLeft && !allowAlignRight) {
    // We've already tried both ways and couldn't make it fit. onLayout() will set the
    // gravity to CENTER_HORIZONTAL, but continue below to update y.
    } else {
        boolean canBeLeftAligned = x + width + insets.left < dragLayer.getWidth() - insets.right;
        boolean canBeRightAligned = x > insets.left;
        boolean alignmentStillValid = mIsLeftAligned && canBeLeftAligned || !mIsLeftAligned && canBeRightAligned;
        if (!alignmentStillValid) {
            // Try again, but don't allow this alignment we already know won't work.
            orientAboutObject(allowAlignLeft && !mIsLeftAligned, /* allowAlignLeft */
            allowAlignRight && mIsLeftAligned);
            return;
        }
    }
    // Open above icon if there is room.
    int iconHeight = mTempRect.height();
    int y = mTempRect.top - height;
    mIsAboveIcon = y > dragLayer.getTop() + insets.top;
    if (!mIsAboveIcon) {
        y = mTempRect.top + iconHeight + extraVerticalSpace;
    }
    // Insets are added later, so subtract them now.
    x -= insets.left;
    y -= insets.top;
    mGravity = 0;
    if (y + height > dragLayer.getBottom() - insets.bottom) {
        // The container is opening off the screen, so just center it in the drag layer instead.
        mGravity = Gravity.CENTER_VERTICAL;
        // Put the container next to the icon, preferring the right side in ltr (left in rtl).
        int rightSide = leftAlignedX + iconWidth - insets.left;
        int leftSide = rightAlignedX - iconWidth - insets.left;
        if (!mIsRtl) {
            if (rightSide + width < dragLayer.getRight()) {
                x = rightSide;
                mIsLeftAligned = true;
            } else {
                x = leftSide;
                mIsLeftAligned = false;
            }
        } else {
            if (leftSide > dragLayer.getLeft()) {
                x = leftSide;
                mIsLeftAligned = false;
            } else {
                x = rightSide;
                mIsLeftAligned = true;
            }
        }
        mIsAboveIcon = true;
    }
    setX(x);
    if (Gravity.isVertical(mGravity)) {
        return;
    }
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
    FrameLayout.LayoutParams arrowLp = (FrameLayout.LayoutParams) mArrow.getLayoutParams();
    if (mIsAboveIcon) {
        arrowLp.gravity = lp.gravity = Gravity.BOTTOM;
        lp.bottomMargin = getPopupContainer().getHeight() - y - getMeasuredHeight() - insets.top;
        arrowLp.bottomMargin = lp.bottomMargin - arrowLp.height - mArrowOffsetVertical - insets.bottom;
    } else {
        arrowLp.gravity = lp.gravity = Gravity.TOP;
        lp.topMargin = y + insets.top;
        arrowLp.topMargin = lp.topMargin - insets.top - arrowLp.height - mArrowOffsetVertical;
    }
}

Example 2 with InsettableFrameLayout

use of com.android.launcher3.InsettableFrameLayout in project android_packages_apps_Launcher3 by AOSPA.

the class ArrowPopup method orientAboutObject.

/**
 * @see #orientAboutObject()
 *
 * @param allowAlignLeft Set to false if we already tried aligning left and didn't have room.
 * @param allowAlignRight Set to false if we already tried aligning right and didn't have room.
 * TODO: Can we test this with all permutations of widths/heights and icon locations + RTL?
 */
private void orientAboutObject(boolean allowAlignLeft, boolean allowAlignRight) {
    measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int extraVerticalSpace = mArrowHeight + mArrowOffsetVertical + getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
    // The margins are added after we call this method, so we need to account for them here.
    int numVisibleChildren = 0;
    for (int i = getChildCount() - 1; i >= 0; --i) {
        if (getChildAt(i).getVisibility() == VISIBLE) {
            numVisibleChildren++;
        }
    }
    int childMargins = (numVisibleChildren - 1) * mMargin;
    int height = getMeasuredHeight() + extraVerticalSpace + childMargins;
    int width = getMeasuredWidth() + getPaddingLeft() + getPaddingRight();
    getTargetObjectLocation(mTempRect);
    InsettableFrameLayout dragLayer = getPopupContainer();
    Rect insets = dragLayer.getInsets();
    // Align left (right in RTL) if there is room.
    int leftAlignedX = mTempRect.left;
    int rightAlignedX = mTempRect.right - width;
    mIsLeftAligned = !mIsRtl ? allowAlignLeft : !allowAlignRight;
    int x = mIsLeftAligned ? leftAlignedX : rightAlignedX;
    // Offset x so that the arrow and shortcut icons are center-aligned with the original icon.
    int iconWidth = mTempRect.width();
    int xOffset = iconWidth / 2 - mArrowOffsetHorizontal - mArrowWidth / 2;
    x += mIsLeftAligned ? xOffset : -xOffset;
    // Check whether we can still align as we originally wanted, now that we've calculated x.
    if (!allowAlignLeft && !allowAlignRight) {
    // We've already tried both ways and couldn't make it fit. onLayout() will set the
    // gravity to CENTER_HORIZONTAL, but continue below to update y.
    } else {
        boolean canBeLeftAligned = x + width + insets.left < dragLayer.getWidth() - insets.right;
        boolean canBeRightAligned = x > insets.left;
        boolean alignmentStillValid = mIsLeftAligned && canBeLeftAligned || !mIsLeftAligned && canBeRightAligned;
        if (!alignmentStillValid) {
            // Try again, but don't allow this alignment we already know won't work.
            orientAboutObject(allowAlignLeft && !mIsLeftAligned, /* allowAlignLeft */
            allowAlignRight && mIsLeftAligned);
            return;
        }
    }
    // Open above icon if there is room.
    int iconHeight = mTempRect.height();
    int y = mTempRect.top - height;
    mIsAboveIcon = y > dragLayer.getTop() + insets.top;
    if (!mIsAboveIcon) {
        y = mTempRect.top + iconHeight + extraVerticalSpace;
    }
    // Insets are added later, so subtract them now.
    x -= insets.left;
    y -= insets.top;
    mGravity = 0;
    if (y + height > dragLayer.getBottom() - insets.bottom) {
        // The container is opening off the screen, so just center it in the drag layer instead.
        mGravity = Gravity.CENTER_VERTICAL;
        // Put the container next to the icon, preferring the right side in ltr (left in rtl).
        int rightSide = leftAlignedX + iconWidth - insets.left;
        int leftSide = rightAlignedX - iconWidth - insets.left;
        if (!mIsRtl) {
            if (rightSide + width < dragLayer.getRight()) {
                x = rightSide;
                mIsLeftAligned = true;
            } else {
                x = leftSide;
                mIsLeftAligned = false;
            }
        } else {
            if (leftSide > dragLayer.getLeft()) {
                x = leftSide;
                mIsLeftAligned = false;
            } else {
                x = rightSide;
                mIsLeftAligned = true;
            }
        }
        mIsAboveIcon = true;
    }
    setX(x);
    if (Gravity.isVertical(mGravity)) {
        return;
    }
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
    FrameLayout.LayoutParams arrowLp = (FrameLayout.LayoutParams) mArrow.getLayoutParams();
    if (mIsAboveIcon) {
        arrowLp.gravity = lp.gravity = Gravity.BOTTOM;
        lp.bottomMargin = getPopupContainer().getHeight() - y - getMeasuredHeight() - insets.top;
        arrowLp.bottomMargin = lp.bottomMargin - arrowLp.height - mArrowOffsetVertical - insets.bottom;
    } else {
        arrowLp.gravity = lp.gravity = Gravity.TOP;
        lp.topMargin = y + insets.top;
        arrowLp.topMargin = lp.topMargin - insets.top - arrowLp.height - mArrowOffsetVertical;
    }
}

Example 3 with InsettableFrameLayout

use of com.android.launcher3.InsettableFrameLayout in project Neo-Launcher by NeoApplications.

the class ArrowPopup method orientAboutObject.

/**
 * Orients this container above or below the given icon, aligning with the left or right.
 *
 * These are the preferred orientations, in order (RTL prefers right-aligned over left):
 * - Above and left-aligned
 * - Above and right-aligned
 * - Below and left-aligned
 * - Below and right-aligned
 *
 * So we always align left if there is enough horizontal space
 * and align above if there is enough vertical space.
 */
protected void orientAboutObject() {
    measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int width = getMeasuredWidth();
    int extraVerticalSpace = mArrow.getLayoutParams().height + mArrowOffset + getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
    int height = getMeasuredHeight() + extraVerticalSpace;
    getTargetObjectLocation(mTempRect);
    InsettableFrameLayout dragLayer = getPopupContainer();
    Rect insets = dragLayer.getInsets();
    // Align left (right in RTL) if there is room.
    int leftAlignedX = mTempRect.left;
    int rightAlignedX = mTempRect.right - width;
    int x = leftAlignedX;
    boolean canBeLeftAligned = leftAlignedX + width + insets.left < dragLayer.getRight() - insets.right;
    boolean canBeRightAligned = rightAlignedX > dragLayer.getLeft() + insets.left;
    if (!canBeLeftAligned || (mIsRtl && canBeRightAligned)) {
        x = rightAlignedX;
    }
    mIsLeftAligned = x == leftAlignedX;
    // Offset x so that the arrow and shortcut icons are center-aligned with the original icon.
    int iconWidth = mTempRect.width();
    Resources resources = getResources();
    int xOffset;
    if (isAlignedWithStart()) {
        // Aligning with the shortcut icon.
        int shortcutIconWidth = resources.getDimensionPixelSize(R.dimen.deep_shortcut_icon_size);
        int shortcutPaddingStart = resources.getDimensionPixelSize(R.dimen.popup_padding_start);
        xOffset = iconWidth / 2 - shortcutIconWidth / 2 - shortcutPaddingStart;
    } else {
        // Aligning with the drag handle.
        int shortcutDragHandleWidth = resources.getDimensionPixelSize(R.dimen.deep_shortcut_drag_handle_size);
        int shortcutPaddingEnd = resources.getDimensionPixelSize(R.dimen.popup_padding_end);
        xOffset = iconWidth / 2 - shortcutDragHandleWidth / 2 - shortcutPaddingEnd;
    }
    x += mIsLeftAligned ? xOffset : -xOffset;
    // Open above icon if there is room.
    int iconHeight = mTempRect.height();
    int y = mTempRect.top - height;
    mIsAboveIcon = y > dragLayer.getTop() + insets.top;
    if (!mIsAboveIcon) {
        y = mTempRect.top + iconHeight + extraVerticalSpace;
    }
    // Insets are added later, so subtract them now.
    x -= insets.left;
    y -= insets.top;
    mGravity = 0;
    if (y + height > dragLayer.getBottom() - insets.bottom) {
        // The container is opening off the screen, so just center it in the drag layer instead.
        mGravity = Gravity.CENTER_VERTICAL;
        // Put the container next to the icon, preferring the right side in ltr (left in rtl).
        int rightSide = leftAlignedX + iconWidth - insets.left;
        int leftSide = rightAlignedX - iconWidth - insets.left;
        if (!mIsRtl) {
            if (rightSide + width < dragLayer.getRight()) {
                x = rightSide;
                mIsLeftAligned = true;
            } else {
                x = leftSide;
                mIsLeftAligned = false;
            }
        } else {
            if (leftSide > dragLayer.getLeft()) {
                x = leftSide;
                mIsLeftAligned = false;
            } else {
                x = rightSide;
                mIsLeftAligned = true;
            }
        }
        mIsAboveIcon = true;
    }
    setX(x);
    if (Gravity.isVertical(mGravity)) {
        return;
    }
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
    FrameLayout.LayoutParams arrowLp = (FrameLayout.LayoutParams) mArrow.getLayoutParams();
    if (mIsAboveIcon) {
        arrowLp.gravity = lp.gravity = Gravity.BOTTOM;
        lp.bottomMargin = getPopupContainer().getHeight() - y - getMeasuredHeight() - insets.top;
        arrowLp.bottomMargin = lp.bottomMargin - arrowLp.height - mArrowOffset - insets.bottom;
    } else {
        arrowLp.gravity = lp.gravity = Gravity.TOP;
        lp.topMargin = y + insets.top;
        arrowLp.topMargin = lp.topMargin - insets.top - arrowLp.height - mArrowOffset;
    }
}

Example 4 with InsettableFrameLayout

use of com.android.launcher3.InsettableFrameLayout in project android_packages_apps_Launcher3 by ArrowOS.

the class ArrowPopup method orientAboutObject.

/**
 * @see #orientAboutObject()
 *
 * @param allowAlignLeft Set to false if we already tried aligning left and didn't have room.
 * @param allowAlignRight Set to false if we already tried aligning right and didn't have room.
 * TODO: Can we test this with all permutations of widths/heights and icon locations + RTL?
 */
private void orientAboutObject(boolean allowAlignLeft, boolean allowAlignRight) {
    measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int extraVerticalSpace = mArrowHeight + mArrowOffsetVertical + getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
    // The margins are added after we call this method, so we need to account for them here.
    int numVisibleChildren = 0;
    for (int i = getChildCount() - 1; i >= 0; --i) {
        if (getChildAt(i).getVisibility() == VISIBLE) {
            numVisibleChildren++;
        }
    }
    int childMargins = (numVisibleChildren - 1) * mMargin;
    int height = getMeasuredHeight() + extraVerticalSpace + childMargins;
    int width = getMeasuredWidth() + getPaddingLeft() + getPaddingRight();
    getTargetObjectLocation(mTempRect);
    InsettableFrameLayout dragLayer = getPopupContainer();
    Rect insets = dragLayer.getInsets();
    // Align left (right in RTL) if there is room.
    int leftAlignedX = mTempRect.left;
    int rightAlignedX = mTempRect.right - width;
    mIsLeftAligned = !mIsRtl ? allowAlignLeft : !allowAlignRight;
    int x = mIsLeftAligned ? leftAlignedX : rightAlignedX;
    // Offset x so that the arrow and shortcut icons are center-aligned with the original icon.
    int iconWidth = mTempRect.width();
    int xOffset = iconWidth / 2 - mArrowOffsetHorizontal - mArrowWidth / 2;
    x += mIsLeftAligned ? xOffset : -xOffset;
    // Check whether we can still align as we originally wanted, now that we've calculated x.
    if (!allowAlignLeft && !allowAlignRight) {
    // We've already tried both ways and couldn't make it fit. onLayout() will set the
    // gravity to CENTER_HORIZONTAL, but continue below to update y.
    } else {
        boolean canBeLeftAligned = x + width + insets.left < dragLayer.getWidth() - insets.right;
        boolean canBeRightAligned = x > insets.left;
        boolean alignmentStillValid = mIsLeftAligned && canBeLeftAligned || !mIsLeftAligned && canBeRightAligned;
        if (!alignmentStillValid) {
            // Try again, but don't allow this alignment we already know won't work.
            orientAboutObject(allowAlignLeft && !mIsLeftAligned, /* allowAlignLeft */
            allowAlignRight && mIsLeftAligned);
            return;
        }
    }
    // Open above icon if there is room.
    int iconHeight = mTempRect.height();
    int y = mTempRect.top - height;
    mIsAboveIcon = y > dragLayer.getTop() + insets.top;
    if (!mIsAboveIcon) {
        y = mTempRect.top + iconHeight + extraVerticalSpace;
    }
    // Insets are added later, so subtract them now.
    x -= insets.left;
    y -= insets.top;
    mGravity = 0;
    if (y + height > dragLayer.getBottom() - insets.bottom) {
        // The container is opening off the screen, so just center it in the drag layer instead.
        mGravity = Gravity.CENTER_VERTICAL;
        // Put the container next to the icon, preferring the right side in ltr (left in rtl).
        int rightSide = leftAlignedX + iconWidth - insets.left;
        int leftSide = rightAlignedX - iconWidth - insets.left;
        if (!mIsRtl) {
            if (rightSide + width < dragLayer.getRight()) {
                x = rightSide;
                mIsLeftAligned = true;
            } else {
                x = leftSide;
                mIsLeftAligned = false;
            }
        } else {
            if (leftSide > dragLayer.getLeft()) {
                x = leftSide;
                mIsLeftAligned = false;
            } else {
                x = rightSide;
                mIsLeftAligned = true;
            }
        }
        mIsAboveIcon = true;
    }
    setX(x);
    if (Gravity.isVertical(mGravity)) {
        return;
    }
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
    FrameLayout.LayoutParams arrowLp = (FrameLayout.LayoutParams) mArrow.getLayoutParams();
    if (mIsAboveIcon) {
        arrowLp.gravity = lp.gravity = Gravity.BOTTOM;
        lp.bottomMargin = getPopupContainer().getHeight() - y - getMeasuredHeight() - insets.top;
        arrowLp.bottomMargin = lp.bottomMargin - arrowLp.height - mArrowOffsetVertical - insets.bottom;
    } else {
        arrowLp.gravity = lp.gravity = Gravity.TOP;
        lp.topMargin = y + insets.top;
        arrowLp.topMargin = lp.topMargin - insets.top - arrowLp.height - mArrowOffsetVertical;
    }
}

Example 5 with InsettableFrameLayout

use of com.android.launcher3.InsettableFrameLayout in project android_packages_apps_Launcher3 by ProtonAOSP.

the class ArrowPopup method orientAboutObject.

/**
 * @see #orientAboutObject()
 *
 * @param allowAlignLeft Set to false if we already tried aligning left and didn't have room.
 * @param allowAlignRight Set to false if we already tried aligning right and didn't have room.
 * TODO: Can we test this with all permutations of widths/heights and icon locations + RTL?
 */
private void orientAboutObject(boolean allowAlignLeft, boolean allowAlignRight) {
    measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
    int extraVerticalSpace = mArrowHeight + mArrowOffsetVertical + getResources().getDimensionPixelSize(R.dimen.popup_vertical_padding);
    // The margins are added after we call this method, so we need to account for them here.
    int numVisibleChildren = 0;
    for (int i = getChildCount() - 1; i >= 0; --i) {
        if (getChildAt(i).getVisibility() == VISIBLE) {
            numVisibleChildren++;
        }
    }
    int childMargins = (numVisibleChildren - 1) * mMargin;
    int height = getMeasuredHeight() + extraVerticalSpace + childMargins;
    int width = getMeasuredWidth() + getPaddingLeft() + getPaddingRight();
    getTargetObjectLocation(mTempRect);
    InsettableFrameLayout dragLayer = getPopupContainer();
    Rect insets = dragLayer.getInsets();
    // Align left (right in RTL) if there is room.
    int leftAlignedX = mTempRect.left;
    int rightAlignedX = mTempRect.right - width;
    mIsLeftAligned = !mIsRtl ? allowAlignLeft : !allowAlignRight;
    int x = mIsLeftAligned ? leftAlignedX : rightAlignedX;
    // Offset x so that the arrow and shortcut icons are center-aligned with the original icon.
    int iconWidth = mTempRect.width();
    int xOffset = iconWidth / 2 - mArrowOffsetHorizontal - mArrowWidth / 2;
    x += mIsLeftAligned ? xOffset : -xOffset;
    // Check whether we can still align as we originally wanted, now that we've calculated x.
    if (!allowAlignLeft && !allowAlignRight) {
    // We've already tried both ways and couldn't make it fit. onLayout() will set the
    // gravity to CENTER_HORIZONTAL, but continue below to update y.
    } else {
        boolean canBeLeftAligned = x + width + insets.left < dragLayer.getWidth() - insets.right;
        boolean canBeRightAligned = x > insets.left;
        boolean alignmentStillValid = mIsLeftAligned && canBeLeftAligned || !mIsLeftAligned && canBeRightAligned;
        if (!alignmentStillValid) {
            // Try again, but don't allow this alignment we already know won't work.
            orientAboutObject(allowAlignLeft && !mIsLeftAligned, /* allowAlignLeft */
            allowAlignRight && mIsLeftAligned);
            return;
        }
    }
    // Open above icon if there is room.
    int iconHeight = mTempRect.height();
    int y = mTempRect.top - height;
    mIsAboveIcon = y > dragLayer.getTop() + insets.top;
    if (!mIsAboveIcon) {
        y = mTempRect.top + iconHeight + extraVerticalSpace;
    }
    // Insets are added later, so subtract them now.
    x -= insets.left;
    y -= insets.top;
    mGravity = 0;
    if (y + height > dragLayer.getBottom() - insets.bottom) {
        // The container is opening off the screen, so just center it in the drag layer instead.
        mGravity = Gravity.CENTER_VERTICAL;
        // Put the container next to the icon, preferring the right side in ltr (left in rtl).
        int rightSide = leftAlignedX + iconWidth - insets.left;
        int leftSide = rightAlignedX - iconWidth - insets.left;
        if (!mIsRtl) {
            if (rightSide + width < dragLayer.getRight()) {
                x = rightSide;
                mIsLeftAligned = true;
            } else {
                x = leftSide;
                mIsLeftAligned = false;
            }
        } else {
            if (leftSide > dragLayer.getLeft()) {
                x = leftSide;
                mIsLeftAligned = false;
            } else {
                x = rightSide;
                mIsLeftAligned = true;
            }
        }
        mIsAboveIcon = true;
    }
    setX(x);
    if (Gravity.isVertical(mGravity)) {
        return;
    }
    FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) getLayoutParams();
    FrameLayout.LayoutParams arrowLp = (FrameLayout.LayoutParams) mArrow.getLayoutParams();
    if (mIsAboveIcon) {
        arrowLp.gravity = lp.gravity = Gravity.BOTTOM;
        lp.bottomMargin = getPopupContainer().getHeight() - y - getMeasuredHeight() - insets.top;
        arrowLp.bottomMargin = lp.bottomMargin - arrowLp.height - mArrowOffsetVertical - insets.bottom;
    } else {
        arrowLp.gravity = lp.gravity = Gravity.TOP;
        lp.topMargin = y + insets.top;
        arrowLp.topMargin = lp.topMargin - insets.top - arrowLp.height - mArrowOffsetVertical;
    }
}