if (x < 0) {
        }
    }

<<<<<<< HEAD

    @ViewDebug.ExportedProperty(category = "text")
=======
    private void startTextSelectionMode() {
        if (mSelectionModifierCursorController == null) {
            Log.w(LOG_TAG, "TextView has no selection controller. Action mode cancelled.");
            return;
        }

        if (!requestFocus()) {
            return;
        }

        selectCurrentWord();
        mSelectionModifierCursorController.show();
        mIsInTextSelectionMode = true;
    }
    
    /**
     * Same as {@link #stopTextSelectionMode()}, except that there is no cursor controller
     * fade out animation. Needed since the drawable and their alpha values are shared by all
     * TextViews. Switching from one TextView to another would fade the cursor controllers in the
     * new one otherwise.
     */
    private void terminateTextSelectionMode() {
        stopTextSelectionMode();
        if (mSelectionModifierCursorController != null) {
            SelectionModifierCursorController selectionModifierCursorController =
                (SelectionModifierCursorController) mSelectionModifierCursorController;
            selectionModifierCursorController.cancelFadeOutAnimation();
        }
    }

    private void stopTextSelectionMode() {
        if (mIsInTextSelectionMode) {
            Selection.setSelection((Spannable) mText, getSelectionEnd());
            if (mSelectionModifierCursorController != null) {
                mSelectionModifierCursorController.hide();
            }

            mIsInTextSelectionMode = false;
        }
    }

    /**
     * A CursorController instance can be used to control a cursor in the text.
     *
     * It can be passed to an {@link ArrowKeyMovementMethod} which can intercepts events
     * and send them to this object instead of the cursor.
     */
    public interface CursorController {
        /* Cursor fade-out animation duration, in milliseconds. */
        static final int FADE_OUT_DURATION = 400;

        /**
         * Makes the cursor controller visible on screen. Will be drawn by {@link #draw(Canvas)}.

         * See also {@link #hide()}.
         */
        public void show();

        /**
         * Hide the cursor controller from screen.
         * See also {@link #show()}.
         */
        public void hide();

        /**
         * Update the controller's position.
         */
        public void updatePosition(int offset);

        /**
         * The controller and the cursor's positions can be link by a fixed offset,
         * computed when the controller is touched, and then maintained as it moves
         * @return Horizontal offset between the controller and the cursor.
         */
        public float getOffsetX();

        /**
         * @return Vertical offset between the controller and the cursor.
         */
        public float getOffsetY();

        /**
         * This method is called by {@link #onTouchEvent(MotionEvent)} and gives the controller
         * a chance to become active and/or visible.
         * @param event The touch event
         */
        public void onTouchEvent(MotionEvent event);

        /**
         * Draws a visual representation of the controller on the canvas.
         *
         * Called at the end of {@link #draw(Canvas)}, in the content coordinates system.
         * @param canvas The Canvas used by this TextView.
         */
        public void draw(Canvas canvas);
    }

    private class Handle {
        Drawable mDrawable;
        // Vertical extension of the touch region
        int mTopExtension, mBottomExtension;
        // Position of the virtual finger position on screen
        int mHopSpotVertcalPosition;

        Handle(Drawable drawable) {
            mDrawable = drawable;
        }

        void positionAtCursor(final int offset, boolean bottom) {
            final int drawableWidth = mDrawable.getIntrinsicWidth();
            final int drawableHeight = mDrawable.getIntrinsicHeight();
            final int line = mLayout.getLineForOffset(offset);
            final int lineTop = mLayout.getLineTop(line);
            final int lineBottom = mLayout.getLineBottom(line);

            mHopSpotVertcalPosition = lineTop + (bottom ? (3 * (lineBottom - lineTop)) / 4 :
                (lineBottom - lineTop) / 4);

            final Rect bounds = sCursorControllerTempRect;
            bounds.left = (int) (mLayout.getPrimaryHorizontal(offset) - drawableWidth / 2.0);
            bounds.top = (bottom ? lineBottom : lineTop) - drawableHeight / 2;

            mTopExtension = bottom ? 0 : drawableHeight / 2;
            mBottomExtension = drawableHeight;

            // Extend touch region up when editing the last line of text (or a single line) so that
            // it is easier to grab.
            if (line == mLayout.getLineCount() - 1) {
                mTopExtension = (lineBottom - lineTop) - drawableHeight / 2;
            }

            bounds.right = bounds.left + drawableWidth;
            bounds.bottom = bounds.top + drawableHeight;

            int boundTopBefore = bounds.top;
            convertFromViewportToContentCoordinates(bounds);
            mHopSpotVertcalPosition += bounds.top - boundTopBefore;
            mDrawable.setBounds(bounds);
            postInvalidate();
        }

        boolean hasFingerOn(float x, float y) {
            // Simulate a 'fat finger' to ease grabbing of the controller.
            // Expands according to controller image size instead of using dip distance.
            // Assumes controller imager has a sensible size, proportionnal to screen density.
            final int drawableWidth = mDrawable.getIntrinsicWidth();
            final Rect fingerRect = sCursorControllerTempRect;
            fingerRect.set((int) (x - drawableWidth / 2.0),
                           (int) (y - mBottomExtension),
                           (int) (x + drawableWidth / 2.0),
                           (int) (y + mTopExtension));
            return Rect.intersects(mDrawable.getBounds(), fingerRect);
        }

        void postInvalidate() {
            final Rect bounds = mDrawable.getBounds();
            TextView.this.postInvalidate(bounds.left, bounds.top, bounds.right, bounds.bottom);
        }

        void postInvalidateDelayed(long delay) {
            final Rect bounds = mDrawable.getBounds();
            TextView.this.postInvalidateDelayed(delay, bounds.left, bounds.top,
                    bounds.right, bounds.bottom);
        }
    }

    class InsertionPointCursorController implements CursorController {
        private static final int DELAY_BEFORE_FADE_OUT = 2100;

        // Whether or not the cursor control is currently visible
        private boolean mIsVisible = false;
        // Starting time of the fade timer
        private long mFadeOutTimerStart;
        // The cursor controller image
        private final Handle mHandle;
        // Used to detect a tap (vs drag) on the controller
        private long mOnDownTimerStart;
            x = 0;
        // Offset between finger hot point on cursor controller and actual cursor
        private float mOffsetX, mOffsetY;

        InsertionPointCursorController() {
            Resources res = mContext.getResources();
            mHandle = new Handle(res.getDrawable(com.android.internal.R.drawable.text_select_handle));
        }

        public void show() {
            updateDrawablePosition();
            // Has to be done after updatePosition, so that previous position invalidate
            // in only done if necessary.
            mIsVisible = true;
        }

        public void hide() {
            if (mIsVisible) {
                long time = System.currentTimeMillis();
                // Start fading out, only if not already in progress
                if (time - mFadeOutTimerStart < DELAY_BEFORE_FADE_OUT) {
                    mFadeOutTimerStart = time - DELAY_BEFORE_FADE_OUT;
                    mHandle.postInvalidate();
                }
            }
        }

        public void draw(Canvas canvas) {
            if (mIsVisible) {
                int time = (int) (System.currentTimeMillis() - mFadeOutTimerStart);
                if (time <= DELAY_BEFORE_FADE_OUT) {
                    mHandle.postInvalidateDelayed(DELAY_BEFORE_FADE_OUT - time);
                } else {
                    time -= DELAY_BEFORE_FADE_OUT;
                    if (time <= FADE_OUT_DURATION) {
                        final int alpha = (int)
                        ((255.0 * (FADE_OUT_DURATION - time)) / FADE_OUT_DURATION);
                        mHandle.mDrawable.setAlpha(alpha);
                        mHandle.postInvalidateDelayed(30);
                    } else {
                        mHandle.mDrawable.setAlpha(0);
                        mIsVisible = false;
                    }
                }
                mHandle.mDrawable.draw(canvas);
            }
        }

        public void updatePosition(int offset) {
            if (offset == getSelectionStart()) {
                return; // No change, no need to redraw
            }
            Selection.setSelection((Spannable) mText, offset);
            updateDrawablePosition();
        }

        private void updateDrawablePosition() {
            if (mIsVisible) {
                // Clear previous cursor controller before bounds are updated
                mHandle.postInvalidate();
            }

            final int offset = getSelectionStart();

            if (offset < 0) {
                // Should never happen, safety check.
                Log.w(LOG_TAG, "Update cursor controller position called with no cursor");
                mIsVisible = false;
                return;
            }

            mHandle.positionAtCursor(offset, true);

            mFadeOutTimerStart = System.currentTimeMillis();
            mHandle.mDrawable.setAlpha(255);
        }

        public void onTouchEvent(MotionEvent event) {
            if (isFocused() && isTextEditable() && mIsVisible) {
                switch (event.getActionMasked()) {
                    case MotionEvent.ACTION_DOWN : {
                        final float x = event.getX();
                        final float y = event.getY();

                        if (mHandle.hasFingerOn(x, y)) {
                            show();

                            if (mMovement instanceof ArrowKeyMovementMethod) {
                                ((ArrowKeyMovementMethod)mMovement).setCursorController(this);
                            }

                            if (mParent != null) {
                                // Prevent possible scrollView parent from scrolling, so that
                                // we can use auto-scrolling.
                                mParent.requestDisallowInterceptTouchEvent(true);
                            }

                            final Rect bounds = mHandle.mDrawable.getBounds();
                            mOffsetX = (bounds.left + bounds.right) / 2.0f - x;
                            mOffsetY = mHandle.mHopSpotVertcalPosition - y;

                            mOnDownTimerStart = event.getEventTime();
                        }
                        break;
                    }

                    case MotionEvent.ACTION_UP : {
                        int time = (int) (event.getEventTime() - mOnDownTimerStart);

                        if (time <= ViewConfiguration.getTapTimeout()) {
                            // A tap on the controller (not a drag) will move the cursor
                            int offset = getOffset((int) event.getX(), (int) event.getY());
                            Selection.setSelection((Spannable) mText, offset);

                            // Modified by cancelLongPress and prevents the cursor from changing
                            mScrolled = false;
                        }
                        break;
                    }
                }
            }
        }

        public float getOffsetX() {
            return mOffsetX;
        }

        public float getOffsetY() {
            return mOffsetY;
        }
    }

    class SelectionModifierCursorController implements CursorController {
        // Whether or not the selection controls are currently visible
        private boolean mIsVisible = false;
        // Whether that start or the end of selection controller is dragged
        private boolean mStartIsDragged = false;
        // Starting time of the fade timer
        private long mFadeOutTimerStart;
        // The cursor controller images
        private final Handle mStartHandle, mEndHandle;
        // Offset between finger hot point on active cursor controller and actual cursor
        private float mOffsetX, mOffsetY;
        // The offsets of that last touch down event. Remembered to start selection there.
        private int mMinTouchOffset, mMaxTouchOffset;

        SelectionModifierCursorController() {
            Resources res = mContext.getResources();
            mStartHandle = new Handle(res.getDrawable(com.android.internal.R.drawable.text_select_handle));
            mEndHandle = new Handle(res.getDrawable(com.android.internal.R.drawable.text_select_handle));
        }
        public void show() {
            updateDrawablesPositions();
            // Has to be done after updatePosition, so that previous position invalidate
            // in only done if necessary.
            mIsVisible = true;
            mFadeOutTimerStart = -1;
            hideInsertionPointCursorController();
        }

        public void hide() {
            if (mIsVisible && (mFadeOutTimerStart < 0)) {
                mFadeOutTimerStart = System.currentTimeMillis();
                mStartHandle.postInvalidate();
                mEndHandle.postInvalidate();
            }
        }

        public void cancelFadeOutAnimation() {
            mIsVisible = false;
            mStartHandle.postInvalidate();
            mEndHandle.postInvalidate();
        }

        public void draw(Canvas canvas) {
            if (mIsVisible) {
                if (mFadeOutTimerStart >= 0) {
                    int time = (int) (System.currentTimeMillis() - mFadeOutTimerStart);
                    if (time <= FADE_OUT_DURATION) {
                        final int alpha = 255 * (FADE_OUT_DURATION - time) / FADE_OUT_DURATION;
                        mStartHandle.mDrawable.setAlpha(alpha);
                        mEndHandle.mDrawable.setAlpha(alpha);
                        mStartHandle.postInvalidateDelayed(30);
                        mEndHandle.postInvalidateDelayed(30);
                    } else {
                        mStartHandle.mDrawable.setAlpha(0);
                        mEndHandle.mDrawable.setAlpha(0);
                        mIsVisible = false;
                    }
                }
                mStartHandle.mDrawable.draw(canvas);
                mEndHandle.mDrawable.draw(canvas);
            }
        }

        public void updatePosition(int offset) {
            int selectionStart = getSelectionStart();
            int selectionEnd = getSelectionEnd();

            // Handle the case where start and end are swapped, making sure start <= end
            if (mStartIsDragged) {
                if (offset <= selectionEnd) {
                    if (selectionStart == offset) {
                        return; // no change, no need to redraw;
                    }
                    selectionStart = offset;
                } else {
                    selectionStart = selectionEnd;
                    selectionEnd = offset;
                    mStartIsDragged = false;
                }
            } else {
                if (offset >= selectionStart) {
                    if (selectionEnd == offset) {
                        return; // no change, no need to redraw;
                    }
                    selectionEnd = offset;
                } else {
                    selectionEnd = selectionStart;
                    selectionStart = offset;
                    mStartIsDragged = true;
                }
            }

            Selection.setSelection((Spannable) mText, selectionStart, selectionEnd);
            updateDrawablesPositions();
        }

        private void updateDrawablesPositions() {
            if (mIsVisible) {
                // Clear previous cursor controller before bounds are updated
                mStartHandle.postInvalidate();
                mEndHandle.postInvalidate();
            }

            final int selectionStart = getSelectionStart();
            final int selectionEnd = getSelectionEnd();

            if ((selectionStart < 0) || (selectionEnd < 0)) {
                // Should never happen, safety check.
                Log.w(LOG_TAG, "Update selection controller position called with no cursor");
                mIsVisible = false;
                return;
            }
            boolean oneLineSelection = mLayout.getLineForOffset(selectionStart) == mLayout.getLineForOffset(selectionEnd); 
            mStartHandle.positionAtCursor(selectionStart, oneLineSelection);
            mEndHandle.positionAtCursor(selectionEnd, true);

            mStartHandle.mDrawable.setAlpha(255);
            mEndHandle.mDrawable.setAlpha(255);
        }

        public void onTouchEvent(MotionEvent event) {
            if (isTextEditable()) {
                switch (event.getActionMasked()) {
                    case MotionEvent.ACTION_DOWN:
                        final int x = (int) event.getX();
                        final int y = (int) event.getY();

                        // Remember finger down position, to be able to start selection from there
                        mMinTouchOffset = mMaxTouchOffset = getOffset(x, y);

                        if (mIsVisible) {
                            if (mMovement instanceof ArrowKeyMovementMethod) {
                                boolean isOnStart = mStartHandle.hasFingerOn(x, y);
                                boolean isOnEnd = mEndHandle.hasFingerOn(x, y);
                                if (isOnStart || isOnEnd) {
                                    if (mParent != null) {
                                        // Prevent possible scrollView parent from scrolling, so
                                        // that we can use auto-scrolling.
                                        mParent.requestDisallowInterceptTouchEvent(true);
                                    }

                                    // In case both controllers are under finger (very small
                                    // selection region), arbitrarily pick end controller.
                                    mStartIsDragged = !isOnEnd;
                                    final Handle draggedHandle = mStartIsDragged ? mStartHandle : mEndHandle;
                                    final Rect bounds = draggedHandle.mDrawable.getBounds();
                                    mOffsetX = (bounds.left + bounds.right) / 2.0f - x;
                                    mOffsetY = draggedHandle.mHopSpotVertcalPosition - y;

                                    ((ArrowKeyMovementMethod)mMovement).setCursorController(this);
                                }
                            }
                        }
                        break;

                    case MotionEvent.ACTION_POINTER_DOWN:
                    case MotionEvent.ACTION_POINTER_UP:
                        // Handle multi-point gestures. Keep min and max offset positions.
                        // Only activated for devices that correctly handle multi-touch.
                        if (mContext.getPackageManager().hasSystemFeature(
                                PackageManager.FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT)) {
                            updateMinAndMaxOffsets(event);
                        }
                        break;
                }
            }
        }

        /**
         * @param event
         */
        private void updateMinAndMaxOffsets(MotionEvent event) {
            int pointerCount = event.getPointerCount();
            for (int index = 0; index < pointerCount; index++) {
                final int x = (int) event.getX(index);
                final int y = (int) event.getY(index);
                int offset = getOffset(x, y);
                if (offset < mMinTouchOffset) mMinTouchOffset = offset;
                if (offset > mMaxTouchOffset) mMaxTouchOffset = offset;
            }
        }

        public int getMinTouchOffset() {
            return mMinTouchOffset;
        }

        public int getMaxTouchOffset() {
            return mMaxTouchOffset;
        }

        public float getOffsetX() {
            return mOffsetX;
        }

        public float getOffsetY() {
            return mOffsetY;
        }

        /**
         * @return true iff this controller is currently used to move the selection start.
         */
        public boolean isSelectionStartDragged() {
            return mIsVisible && mStartIsDragged;
        }
    }

    private void hideInsertionPointCursorController() {
        if (mInsertionPointCursorController != null) {
            mInsertionPointCursorController.hide();
        }
    }

    private void hideControllers() {
        hideInsertionPointCursorController();
        stopTextSelectionMode();
    }

    /**
     * Get the offset character closest to the specified absolute position.
     *
     * @param x The horizontal absolute position of a point on screen
     * @param y The vertical absolute position of a point on screen
     * @return the character offset for the character whose position is closest to the specified
     *  position. Returns -1 if there is no layout.
     *
     * @hide
     */
    public int getOffset(int x, int y) {
        x -= getTotalPaddingLeft();
        y -= getTotalPaddingTop();

        // Clamp the position to inside of the view.
        } else if (x >= (getWidth() - getTotalPaddingRight())) {
            x = getWidth()-getTotalPaddingRight() - 1;
        }
        if (y < 0) {
            y = 0;
        } else if (y >= (getHeight() - getTotalPaddingBottom())) {
            y = getHeight()-getTotalPaddingBottom() - 1;
        }

        x += getScrollX();
        y += getScrollY();

        Layout layout = getLayout();
        if (layout != null) {
            final int line = layout.getLineForVertical(y);
            final int offset = layout.getOffsetForHorizontal(line, x);
            return offset;
        } else {
            return -1;
        }
    }

    @ViewDebug.ExportedProperty
>>>>>>> a842d143d2dcad07906830a30deaf0ffce86f5d9
    private CharSequence            mText;
    private CharSequence            mTransformed;
    private BufferType              mBufferType = BufferType.NORMAL;

        }
    }


    @ViewDebug.ExportedProperty(category = "text")
    private CharSequence            mText;
    private CharSequence            mTransformed;
    private BufferType              mBufferType = BufferType.NORMAL;