Home | History | Annotate | Download | only in utils 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.inputmethod.latin.utils;
     18 
     19 import android.text.Spanned;
     20 import android.text.style.SuggestionSpan;
     21 
     22 import java.util.Arrays;
     23 
     24 /**
     25  * Represents a range of text, relative to the current cursor position.
     26  */
     27 public final class TextRange {
     28     private final CharSequence mTextAtCursor;
     29     private final int mWordAtCursorStartIndex;
     30     private final int mWordAtCursorEndIndex;
     31     private final int mCursorIndex;
     32 
     33     public final CharSequence mWord;
     34     public final boolean mHasUrlSpans;
     35 
     36     public int getNumberOfCharsInWordBeforeCursor() {
     37         return mCursorIndex - mWordAtCursorStartIndex;
     38     }
     39 
     40     public int getNumberOfCharsInWordAfterCursor() {
     41         return mWordAtCursorEndIndex - mCursorIndex;
     42     }
     43 
     44     public int length() {
     45         return mWord.length();
     46     }
     47 
     48     /**
     49      * Gets the suggestion spans that are put squarely on the word, with the exact start
     50      * and end of the span matching the boundaries of the word.
     51      * @return the list of spans.
     52      */
     53     public SuggestionSpan[] getSuggestionSpansAtWord() {
     54         if (!(mTextAtCursor instanceof Spanned && mWord instanceof Spanned)) {
     55             return new SuggestionSpan[0];
     56         }
     57         final Spanned text = (Spanned)mTextAtCursor;
     58         // Note: it's fine to pass indices negative or greater than the length of the string
     59         // to the #getSpans() method. The reason we need to get from -1 to +1 is that, the
     60         // spans were cut at the cursor position, and #getSpans(start, end) does not return
     61         // spans that end at `start' or begin at `end'. Consider the following case:
     62         //              this| is          (The | symbolizes the cursor position
     63         //              ---- ---
     64         // In this case, the cursor is in position 4, so the 0~7 span has been split into
     65         // a 0~4 part and a 4~7 part.
     66         // If we called #getSpans(0, 4) in this case, we would only get the part from 0 to 4
     67         // of the span, and not the part from 4 to 7, so we would not realize the span actually
     68         // extends from 0 to 7. But if we call #getSpans(-1, 5) we'll get both the 0~4 and
     69         // the 4~7 spans and we can merge them accordingly.
     70         // Any span starting more than 1 char away from the word boundaries in any direction
     71         // does not touch the word, so we don't need to consider it. That's why requesting
     72         // -1 ~ +1 is enough.
     73         // Of course this is only relevant if the cursor is at one end of the word. If it's
     74         // in the middle, the -1 and +1 are not necessary, but they are harmless.
     75         final SuggestionSpan[] spans = text.getSpans(mWordAtCursorStartIndex - 1,
     76                 mWordAtCursorEndIndex + 1, SuggestionSpan.class);
     77         int readIndex = 0;
     78         int writeIndex = 0;
     79         for (; readIndex < spans.length; ++readIndex) {
     80             final SuggestionSpan span = spans[readIndex];
     81             // The span may be null, as we null them when we find duplicates. Cf a few lines
     82             // down.
     83             if (null == span) continue;
     84             // Tentative span start and end. This may be modified later if we realize the
     85             // same span is also applied to other parts of the string.
     86             int spanStart = text.getSpanStart(span);
     87             int spanEnd = text.getSpanEnd(span);
     88             for (int i = readIndex + 1; i < spans.length; ++i) {
     89                 if (span.equals(spans[i])) {
     90                     // We found the same span somewhere else. Read the new extent of this
     91                     // span, and adjust our values accordingly.
     92                     spanStart = Math.min(spanStart, text.getSpanStart(spans[i]));
     93                     spanEnd = Math.max(spanEnd, text.getSpanEnd(spans[i]));
     94                     // ...and mark the span as processed.
     95                     spans[i] = null;
     96                 }
     97             }
     98             if (spanStart == mWordAtCursorStartIndex && spanEnd == mWordAtCursorEndIndex) {
     99                 // If the span does not start and stop here, ignore it. It probably extends
    100                 // past the start or end of the word, as happens in missing space correction
    101                 // or EasyEditSpans put by voice input.
    102                 spans[writeIndex++] = spans[readIndex];
    103             }
    104         }
    105         return writeIndex == readIndex ? spans : Arrays.copyOfRange(spans, 0, writeIndex);
    106     }
    107 
    108     public TextRange(final CharSequence textAtCursor, final int wordAtCursorStartIndex,
    109             final int wordAtCursorEndIndex, final int cursorIndex, final boolean hasUrlSpans) {
    110         if (wordAtCursorStartIndex < 0 || cursorIndex < wordAtCursorStartIndex
    111                 || cursorIndex > wordAtCursorEndIndex
    112                 || wordAtCursorEndIndex > textAtCursor.length()) {
    113             throw new IndexOutOfBoundsException();
    114         }
    115         mTextAtCursor = textAtCursor;
    116         mWordAtCursorStartIndex = wordAtCursorStartIndex;
    117         mWordAtCursorEndIndex = wordAtCursorEndIndex;
    118         mCursorIndex = cursorIndex;
    119         mHasUrlSpans = hasUrlSpans;
    120         mWord = mTextAtCursor.subSequence(mWordAtCursorStartIndex, mWordAtCursorEndIndex);
    121     }
    122 }