Java Code Examples for android.util.LayoutDirection#LTR

@Override
public boolean onTouch(View v, MotionEvent event) {
    if (!viewType.isInstance(v)) { return false; }

    EditText editableView = viewType.cast(v);

    if(editableView != null && event.getAction() == MotionEvent.ACTION_UP) {
        Drawable drawableStart = editableView.getCompoundDrawablesRelative()[DRAWABLE_START];
        Drawable drawableEnd = editableView.getCompoundDrawablesRelative()[DRAWABLE_END];

        if (drawableEnd == null && drawableStart == null) {
            return false;
        }

        boolean isStartClicked = false;
        boolean isEndClicked = false;

        int layoutDirection = editableView.getLayoutDirection();
        if (layoutDirection == LayoutDirection.LTR) {
            isStartClicked = detectLeftClick(editableView, drawableStart, event);
            isEndClicked = detectRightClick(editableView, drawableStart, event);
        } else {
            isStartClicked = detectRightClick(editableView, drawableStart, event);
            isEndClicked = detectLeftClick(editableView, drawableStart, event);
        }

        if (isStartClicked) {
            onClickStartDrawable(v);
            return true;
        }

        if (isEndClicked) {
            onClickEndDrawable(v);
            return true;
        }

    }
    return false;
}
 

/**
 * Adjusts the given {@code TextView} to have a layout direction that matches the UI direction
 * when the contents of the view is considered short (based on SHORTNESS_FACTOR).
 * @param textView The text view to adjust.
 */
@SuppressLint("RtlHardcoded")
private void adjustViewDirection(TextView textView) {
    float textWidth = textView.getPaint().measureText(textView.getText().toString());
    if (textWidth < SHORTNESS_FACTOR * textView.getWidth()) {
        int layoutDirection =
                LocalizationUtils.isLayoutRtl() ? LayoutDirection.RTL : LayoutDirection.LTR;
        if (layoutDirection == LayoutDirection.LTR) textView.setGravity(Gravity.LEFT);
        if (layoutDirection == LayoutDirection.RTL) textView.setGravity(Gravity.RIGHT);
    }
}
 

/**
 * Adjusts the given {@code TextView} to have a layout direction that matches the UI direction
 * when the contents of the view is considered short (based on SHORTNESS_FACTOR).
 * @param textView The text view to adjust.
 */
@SuppressLint("RtlHardcoded")
private void adjustViewDirection(TextView textView) {
    float textWidth = textView.getPaint().measureText(textView.getText().toString());
    if (textWidth < SHORTNESS_FACTOR * textView.getWidth()) {
        int layoutDirection =
                LocalizationUtils.isLayoutRtl() ? LayoutDirection.RTL : LayoutDirection.LTR;
        if (layoutDirection == LayoutDirection.LTR) textView.setGravity(Gravity.LEFT);
        if (layoutDirection == LayoutDirection.RTL) textView.setGravity(Gravity.RIGHT);
    }
}
 

private void updateLayerBounds(Rect bounds) {
    int padL = 0;
    int padT = 0;
    int padR = 0;
    int padB = 0;

    final Rect outRect = mTmpOutRect;
    int layoutDirection = LayoutDirection.LTR;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
        layoutDirection = getLayoutDirection();
    final boolean nest = mLayerState.mPaddingMode == PADDING_MODE_NEST;
    final ChildDrawable[] array = mLayerState.mChildren;
    final int N = mLayerState.mNum;
    for (int i = 0; i < N; i++) {
        final ChildDrawable r = array[i];
        final Drawable d = r.mDrawable;
        if (d == null) {
            continue;
        }

        final Rect container = mTmpContainer;
        container.set(d.getBounds());

        // Take the resolved layout direction into account. If start / end
        // padding are defined, they will be resolved (hence overriding) to
        // left / right or right / left depending on the resolved layout
        // direction. If start / end padding are not defined, use the
        // left / right ones.
        final int insetL, insetR;
        if (layoutDirection == LayoutDirection.RTL) {
            insetL = r.mInsetE == UNDEFINED_INSET ? r.mInsetL : r.mInsetE;
            insetR = r.mInsetS == UNDEFINED_INSET ? r.mInsetR : r.mInsetS;
        } else {
            insetL = r.mInsetS == UNDEFINED_INSET ? r.mInsetL : r.mInsetS;
            insetR = r.mInsetE == UNDEFINED_INSET ? r.mInsetR : r.mInsetE;
        }

        // Establish containing region based on aggregate padding and
        // requested insets for the current layer.
        container.set(bounds.left + insetL + padL, bounds.top + r.mInsetT + padT,
                bounds.right - insetR - padR, bounds.bottom - r.mInsetB - padB);

        // Apply resolved gravity to drawable based on resolved size.
        final int gravity = resolveGravity(r.mGravity, r.mWidth, r.mHeight,
                d.getIntrinsicWidth(), d.getIntrinsicHeight());
        final int w = r.mWidth < 0 ? d.getIntrinsicWidth() : r.mWidth;
        final int h = r.mHeight < 0 ? d.getIntrinsicHeight() : r.mHeight;
        GravityCompat.apply(gravity, w, h, container, outRect, layoutDirection);
        d.setBounds(outRect);

        if (nest) {
            padL += mPaddingL[i];
            padR += mPaddingR[i];
            padT += mPaddingT[i];
            padB += mPaddingB[i];
        }
    }
}
 

@Override
public int getIntrinsicWidth() {
    int width = -1;
    int padL = 0;
    int padR = 0;

    final boolean nest = mLayerState.mPaddingMode == PADDING_MODE_NEST;
    final ChildDrawable[] array = mLayerState.mChildren;
    final int N = mLayerState.mNum;
    for (int i = 0; i < N; i++) {
        final ChildDrawable r = array[i];
        if (r.mDrawable == null) {
            continue;
        }

        // Take the resolved layout direction into account. If start / end
        // padding are defined, they will be resolved (hence overriding) to
        // left / right or right / left depending on the resolved layout
        // direction. If start / end padding are not defined, use the
        // left / right ones.
        final int insetL, insetR;
        int layoutDirection = LayoutDirection.LTR;
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
            layoutDirection = getLayoutDirection();
        if (layoutDirection == LayoutDirection.RTL) {
            insetL = r.mInsetE == UNDEFINED_INSET ? r.mInsetL : r.mInsetE;
            insetR = r.mInsetS == UNDEFINED_INSET ? r.mInsetR : r.mInsetS;
        } else {
            insetL = r.mInsetS == UNDEFINED_INSET ? r.mInsetL : r.mInsetS;
            insetR = r.mInsetE == UNDEFINED_INSET ? r.mInsetR : r.mInsetE;
        }

        final int minWidth = r.mWidth < 0 ? r.mDrawable.getIntrinsicWidth() : r.mWidth;
        final int w = minWidth + insetL + insetR + padL + padR;
        if (w > width) {
            width = w;
        }

        if (nest) {
            padL += mPaddingL[i];
            padR += mPaddingR[i];
        }
    }

    return width;
}