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 }
