PageRenderTime 26ms CodeModel.GetById 10ms app.highlight 11ms RepoModel.GetById 1ms app.codeStats 1ms

/ime/latinime/src/com/googlecode/eyesfree/inputmethod/latin/WordComposer.java

http://eyes-free.googlecode.com/
Java | 200 lines | 89 code | 25 blank | 86 comment | 15 complexity | 5318d7f2655ff1af541044f4861c41c7 MD5 | raw file
  1/*
  2 * Copyright (C) 2008 The Android Open Source Project
  3 * 
  4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  5 * use this file except in compliance with the License. You may obtain a copy of
  6 * 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, WITHOUT
 12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 13 * License for the specific language governing permissions and limitations under
 14 * the License.
 15 */
 16
 17package com.googlecode.eyesfree.inputmethod.latin;
 18
 19import java.util.ArrayList;
 20
 21/**
 22 * A place to store the currently composing word with information such as adjacent key codes as well
 23 */
 24public class WordComposer {
 25    /**
 26     * The list of unicode values for each keystroke (including surrounding keys)
 27     */
 28    private final ArrayList<int[]> mCodes;
 29    
 30    /**
 31     * The word chosen from the candidate list, until it is committed.
 32     */
 33    private String mPreferredWord;
 34    
 35    private final StringBuilder mTypedWord;
 36
 37    private int mCapsCount;
 38
 39    private boolean mAutoCapitalized;
 40    
 41    /**
 42     * Whether the user chose to capitalize the first char of the word.
 43     */
 44    private boolean mIsFirstCharCapitalized;
 45
 46    public WordComposer() {
 47        mCodes = new ArrayList<int[]>(12);
 48        mTypedWord = new StringBuilder(20);
 49    }
 50
 51    WordComposer(WordComposer copy) {
 52        mCodes = new ArrayList<int[]>(copy.mCodes);
 53        mPreferredWord = copy.mPreferredWord;
 54        mTypedWord = new StringBuilder(copy.mTypedWord);
 55        mCapsCount = copy.mCapsCount;
 56        mAutoCapitalized = copy.mAutoCapitalized;
 57        mIsFirstCharCapitalized = copy.mIsFirstCharCapitalized;
 58    }
 59
 60    /**
 61     * Clear out the keys registered so far.
 62     */
 63    public void reset() {
 64        mCodes.clear();
 65        mIsFirstCharCapitalized = false;
 66        mPreferredWord = null;
 67        mTypedWord.setLength(0);
 68        mCapsCount = 0;
 69    }
 70
 71    /**
 72     * Number of keystrokes in the composing word.
 73     * @return the number of keystrokes
 74     */
 75    public int size() {
 76        return mCodes.size();
 77    }
 78
 79    /**
 80     * Returns the codes at a particular position in the word.
 81     * @param index the position in the word
 82     * @return the unicode for the pressed and surrounding keys
 83     */
 84    public int[] getCodesAt(int index) {
 85        return mCodes.get(index);
 86    }
 87
 88    /**
 89     * Add a new keystroke, with codes[0] containing the pressed key's unicode and the rest of
 90     * the array containing unicode for adjacent keys, sorted by reducing probability/proximity.
 91     * @param codes the array of unicode values
 92     */
 93    public void add(int primaryCode, int[] codes) {
 94        mTypedWord.append((char) primaryCode);
 95        correctPrimaryJuxtapos(primaryCode, codes);
 96        mCodes.add(codes);
 97        if (Character.isUpperCase((char) primaryCode)) mCapsCount++;
 98    }
 99
100    /**
101     * Swaps the first and second values in the codes array if the primary code is not the first
102     * value in the array but the second. This happens when the preferred key is not the key that
103     * the user released the finger on.
104     * @param primaryCode the preferred character
105     * @param codes array of codes based on distance from touch point
106     */
107    private void correctPrimaryJuxtapos(int primaryCode, int[] codes) {
108        if (codes.length < 2) return;
109        if (codes[0] > 0 && codes[1] > 0 && codes[0] != primaryCode && codes[1] == primaryCode) {
110            codes[1] = codes[0];
111            codes[0] = primaryCode;
112        }
113    }
114
115    /**
116     * Delete the last keystroke as a result of hitting backspace.
117     */
118    public void deleteLast() {
119        final int codesSize = mCodes.size();
120        if (codesSize > 0) {
121            mCodes.remove(codesSize - 1);
122            final int lastPos = mTypedWord.length() - 1;
123            char last = mTypedWord.charAt(lastPos);
124            mTypedWord.deleteCharAt(lastPos);
125            if (Character.isUpperCase(last)) mCapsCount--;
126        }
127    }
128
129    /**
130     * Returns the word as it was typed, without any correction applied.
131     * @return the word that was typed so far
132     */
133    public CharSequence getTypedWord() {
134        int wordSize = mCodes.size();
135        if (wordSize == 0) {
136            return null;
137        }
138        return mTypedWord;
139    }
140
141    public void setFirstCharCapitalized(boolean capitalized) {
142        mIsFirstCharCapitalized = capitalized;
143    }
144    
145    /**
146     * Whether or not the user typed a capital letter as the first letter in the word
147     * @return capitalization preference
148     */
149    public boolean isFirstCharCapitalized() {
150        return mIsFirstCharCapitalized;
151    }
152
153    /**
154     * Whether or not all of the user typed chars are upper case
155     * @return true if all user typed chars are upper case, false otherwise
156     */
157    public boolean isAllUpperCase() {
158        return (mCapsCount > 0) && (mCapsCount == size());
159    }
160
161    /**
162     * Stores the user's selected word, before it is actually committed to the text field.
163     * @param preferred
164     */
165    public void setPreferredWord(String preferred) {
166        mPreferredWord = preferred;
167    }
168    
169    /**
170     * Return the word chosen by the user, or the typed word if no other word was chosen.
171     * @return the preferred word
172     */
173    public CharSequence getPreferredWord() {
174        return mPreferredWord != null ? mPreferredWord : getTypedWord();
175    }
176
177    /**
178     * Returns true if more than one character is upper case, otherwise returns false.
179     */
180    public boolean isMostlyCaps() {
181        return mCapsCount > 1;
182    }
183
184    /** 
185     * Saves the reason why the word is capitalized - whether it was automatic or
186     * due to the user hitting shift in the middle of a sentence.
187     * @param auto whether it was an automatic capitalization due to start of sentence
188     */
189    public void setAutoCapitalized(boolean auto) {
190        mAutoCapitalized = auto;
191    }
192
193    /**
194     * Returns whether the word was automatically capitalized.
195     * @return whether the word was automatically capitalized
196     */
197    public boolean isAutoCapitalized() {
198        return mAutoCapitalized;
199    }
200}