2009-03-13 22:11:42 +00:00
|
|
|
/*
|
2010-12-06 12:26:38 +00:00
|
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
|
|
*
|
2009-03-13 22:11:42 +00:00
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
|
|
* use this file except in compliance with the License. You may obtain a copy of
|
|
|
|
* the License at
|
2010-12-06 12:26:38 +00:00
|
|
|
*
|
2009-03-13 22:11:42 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2010-12-06 12:26:38 +00:00
|
|
|
*
|
2009-03-13 22:11:42 +00:00
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
|
|
* License for the specific language governing permissions and limitations under
|
|
|
|
* the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
package com.android.inputmethod.latin;
|
|
|
|
|
|
|
|
import android.content.Context;
|
2010-02-11 01:45:35 +00:00
|
|
|
import android.content.res.Resources;
|
2011-01-19 08:29:27 +00:00
|
|
|
import android.graphics.Color;
|
2009-03-13 22:11:42 +00:00
|
|
|
import android.graphics.Typeface;
|
2010-12-06 12:26:38 +00:00
|
|
|
import android.os.Handler;
|
|
|
|
import android.os.Message;
|
2010-12-09 05:04:50 +00:00
|
|
|
import android.text.Spannable;
|
|
|
|
import android.text.SpannableString;
|
2010-12-10 06:24:28 +00:00
|
|
|
import android.text.Spanned;
|
2010-12-06 12:26:38 +00:00
|
|
|
import android.text.TextUtils;
|
2010-12-09 07:36:45 +00:00
|
|
|
import android.text.style.BackgroundColorSpan;
|
2010-12-09 05:04:50 +00:00
|
|
|
import android.text.style.CharacterStyle;
|
2010-12-09 07:36:45 +00:00
|
|
|
import android.text.style.ForegroundColorSpan;
|
2010-12-09 05:04:50 +00:00
|
|
|
import android.text.style.StyleSpan;
|
|
|
|
import android.text.style.UnderlineSpan;
|
2009-03-13 22:11:42 +00:00
|
|
|
import android.util.AttributeSet;
|
|
|
|
import android.view.Gravity;
|
|
|
|
import android.view.LayoutInflater;
|
|
|
|
import android.view.View;
|
2010-12-06 12:26:38 +00:00
|
|
|
import android.view.View.OnClickListener;
|
|
|
|
import android.view.View.OnLongClickListener;
|
2010-12-10 06:24:28 +00:00
|
|
|
import android.view.ViewGroup;
|
2010-12-06 12:26:38 +00:00
|
|
|
import android.widget.LinearLayout;
|
2009-03-13 22:11:42 +00:00
|
|
|
import android.widget.PopupWindow;
|
|
|
|
import android.widget.TextView;
|
|
|
|
|
2011-06-06 08:23:18 +00:00
|
|
|
import com.android.inputmethod.latin.SuggestedWords.SuggestedWordInfo;
|
|
|
|
|
2010-09-29 05:30:01 +00:00
|
|
|
import java.util.ArrayList;
|
2011-01-19 08:29:27 +00:00
|
|
|
import java.util.List;
|
2010-09-29 05:30:01 +00:00
|
|
|
|
2010-12-06 12:26:38 +00:00
|
|
|
public class CandidateView extends LinearLayout implements OnClickListener, OnLongClickListener {
|
2009-03-13 22:11:42 +00:00
|
|
|
|
2011-06-09 05:22:37 +00:00
|
|
|
public interface Listener {
|
|
|
|
public boolean addWordToDictionary(String word);
|
|
|
|
public void pickSuggestionManually(int index, CharSequence word);
|
|
|
|
}
|
|
|
|
|
2011-01-18 08:22:01 +00:00
|
|
|
private static final CharacterStyle BOLD_SPAN = new StyleSpan(Typeface.BOLD);
|
|
|
|
private static final CharacterStyle UNDERLINE_SPAN = new UnderlineSpan();
|
2011-06-14 07:28:57 +00:00
|
|
|
// The maximum number of suggestions available. See {@link Suggest#mPrefMaxSuggestions}.
|
|
|
|
private static final int MAX_SUGGESTIONS = 18;
|
|
|
|
private static final int UNSPECIFIED_MEASURESPEC = MeasureSpec.makeMeasureSpec(
|
|
|
|
0, MeasureSpec.UNSPECIFIED);
|
2009-03-13 22:11:42 +00:00
|
|
|
|
2011-01-31 05:49:33 +00:00
|
|
|
private static final boolean DBG = LatinImeLogger.sDBG;
|
2011-01-19 08:29:27 +00:00
|
|
|
|
2011-06-14 07:28:57 +00:00
|
|
|
private static final int NUM_CANDIDATES_IN_STRIP = 3;
|
|
|
|
private final View mExpandCandidatesPane;
|
|
|
|
private final View mCloseCandidatesPane;
|
|
|
|
private ViewGroup mCandidatesPane;
|
|
|
|
private ViewGroup mCandidatesPaneContainer;
|
|
|
|
private View mKeyboardView;
|
2011-06-07 08:18:53 +00:00
|
|
|
private final ArrayList<TextView> mWords = new ArrayList<TextView>();
|
2011-06-06 08:23:18 +00:00
|
|
|
private final ArrayList<View> mDividers = new ArrayList<View>();
|
2011-06-07 08:18:53 +00:00
|
|
|
private final int mCandidatePadding;
|
2011-06-14 07:28:57 +00:00
|
|
|
private final int mCandidateStripHeight;
|
2010-12-06 12:26:38 +00:00
|
|
|
private final boolean mConfigCandidateHighlightFontColorEnabled;
|
2011-01-18 08:22:01 +00:00
|
|
|
private final CharacterStyle mInvertedForegroundColorSpan;
|
|
|
|
private final CharacterStyle mInvertedBackgroundColorSpan;
|
2011-06-07 08:18:53 +00:00
|
|
|
private final int mColorTypedWord;
|
|
|
|
private final int mColorAutoCorrect;
|
|
|
|
private final int mColorSuggestedCandidate;
|
2011-01-18 08:22:01 +00:00
|
|
|
private final PopupWindow mPreviewPopup;
|
|
|
|
private final TextView mPreviewText;
|
2010-02-11 01:45:35 +00:00
|
|
|
|
2011-06-09 05:22:37 +00:00
|
|
|
private Listener mListener;
|
2010-12-10 11:50:30 +00:00
|
|
|
private SuggestedWords mSuggestions = SuggestedWords.EMPTY;
|
2010-12-09 07:36:45 +00:00
|
|
|
private boolean mShowingAutoCorrectionInverted;
|
2010-12-06 12:26:38 +00:00
|
|
|
private boolean mShowingAddToDictionary;
|
2010-02-03 23:35:49 +00:00
|
|
|
|
2010-12-09 07:36:45 +00:00
|
|
|
private final UiHandler mHandler = new UiHandler();
|
|
|
|
|
|
|
|
private class UiHandler extends Handler {
|
|
|
|
private static final int MSG_HIDE_PREVIEW = 0;
|
|
|
|
private static final int MSG_UPDATE_SUGGESTION = 1;
|
|
|
|
|
|
|
|
private static final long DELAY_HIDE_PREVIEW = 1000;
|
|
|
|
private static final long DELAY_UPDATE_SUGGESTION = 300;
|
|
|
|
|
2010-12-06 12:26:38 +00:00
|
|
|
@Override
|
|
|
|
public void dispatchMessage(Message msg) {
|
|
|
|
switch (msg.what) {
|
|
|
|
case MSG_HIDE_PREVIEW:
|
|
|
|
hidePreview();
|
|
|
|
break;
|
2010-12-09 07:36:45 +00:00
|
|
|
case MSG_UPDATE_SUGGESTION:
|
2010-12-19 08:32:26 +00:00
|
|
|
updateSuggestions();
|
2010-12-09 07:36:45 +00:00
|
|
|
break;
|
2010-12-06 12:26:38 +00:00
|
|
|
}
|
|
|
|
}
|
2010-12-09 07:36:45 +00:00
|
|
|
|
|
|
|
public void postHidePreview() {
|
|
|
|
cancelHidePreview();
|
|
|
|
sendMessageDelayed(obtainMessage(MSG_HIDE_PREVIEW), DELAY_HIDE_PREVIEW);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void cancelHidePreview() {
|
|
|
|
removeMessages(MSG_HIDE_PREVIEW);
|
|
|
|
}
|
|
|
|
|
2010-12-19 08:32:26 +00:00
|
|
|
public void postUpdateSuggestions() {
|
2010-12-09 07:36:45 +00:00
|
|
|
cancelUpdateSuggestions();
|
2010-12-19 08:32:26 +00:00
|
|
|
sendMessageDelayed(obtainMessage(MSG_UPDATE_SUGGESTION),
|
2010-12-09 07:36:45 +00:00
|
|
|
DELAY_UPDATE_SUGGESTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void cancelUpdateSuggestions() {
|
|
|
|
removeMessages(MSG_UPDATE_SUGGESTION);
|
|
|
|
}
|
|
|
|
|
|
|
|
public void cancelAllMessages() {
|
|
|
|
cancelHidePreview();
|
|
|
|
cancelUpdateSuggestions();
|
|
|
|
}
|
2010-12-10 06:24:28 +00:00
|
|
|
}
|
2010-09-29 05:30:01 +00:00
|
|
|
|
2009-03-13 22:11:42 +00:00
|
|
|
/**
|
|
|
|
* Construct a CandidateView for showing suggested words for completion.
|
|
|
|
* @param context
|
|
|
|
* @param attrs
|
|
|
|
*/
|
|
|
|
public CandidateView(Context context, AttributeSet attrs) {
|
|
|
|
super(context, attrs);
|
|
|
|
|
2010-02-11 01:45:35 +00:00
|
|
|
Resources res = context.getResources();
|
2010-12-06 12:26:38 +00:00
|
|
|
LayoutInflater inflater = LayoutInflater.from(context);
|
2011-06-14 07:28:57 +00:00
|
|
|
inflater.inflate(R.layout.candidates_strip, this);
|
|
|
|
|
|
|
|
mPreviewPopup = new PopupWindow(context);
|
2010-12-06 12:26:38 +00:00
|
|
|
mPreviewText = (TextView) inflater.inflate(R.layout.candidate_preview, null);
|
2010-12-10 06:24:28 +00:00
|
|
|
mPreviewPopup.setWindowLayoutMode(ViewGroup.LayoutParams.WRAP_CONTENT,
|
|
|
|
ViewGroup.LayoutParams.WRAP_CONTENT);
|
2009-03-13 22:11:42 +00:00
|
|
|
mPreviewPopup.setContentView(mPreviewText);
|
|
|
|
mPreviewPopup.setBackgroundDrawable(null);
|
2010-12-06 12:26:38 +00:00
|
|
|
mConfigCandidateHighlightFontColorEnabled =
|
|
|
|
res.getBoolean(R.bool.config_candidate_highlight_font_color_enabled);
|
2011-06-07 08:18:53 +00:00
|
|
|
mColorTypedWord = res.getColor(R.color.candidate_typed_word);
|
|
|
|
mColorAutoCorrect = res.getColor(R.color.candidate_auto_correct);
|
|
|
|
mColorSuggestedCandidate = res.getColor(R.color.candidate_suggested);
|
|
|
|
mInvertedForegroundColorSpan = new ForegroundColorSpan(mColorTypedWord ^ 0x00ffffff);
|
|
|
|
mInvertedBackgroundColorSpan = new BackgroundColorSpan(mColorTypedWord);
|
2009-03-13 22:11:42 +00:00
|
|
|
|
2011-06-07 08:18:53 +00:00
|
|
|
mCandidatePadding = res.getDimensionPixelOffset(R.dimen.candidate_padding);
|
2011-06-14 07:28:57 +00:00
|
|
|
mCandidateStripHeight = res.getDimensionPixelOffset(R.dimen.candidate_strip_height);
|
2010-12-06 12:26:38 +00:00
|
|
|
for (int i = 0; i < MAX_SUGGESTIONS; i++) {
|
2011-06-14 07:28:57 +00:00
|
|
|
final TextView tv;
|
|
|
|
switch (i) {
|
|
|
|
case 0:
|
|
|
|
tv = (TextView)findViewById(R.id.candidate_left);
|
|
|
|
tv.setPadding(mCandidatePadding, 0, 0, 0);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
tv = (TextView)findViewById(R.id.candidate_center);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
tv = (TextView)findViewById(R.id.candidate_right);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
tv = (TextView)inflater.inflate(R.layout.candidate, null);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (i < NUM_CANDIDATES_IN_STRIP)
|
|
|
|
setLayoutWeight(tv, 1.0f);
|
2010-12-06 12:26:38 +00:00
|
|
|
tv.setTag(i);
|
|
|
|
tv.setOnClickListener(this);
|
|
|
|
if (i == 0)
|
|
|
|
tv.setOnLongClickListener(this);
|
2011-06-07 08:18:53 +00:00
|
|
|
mWords.add(tv);
|
2011-06-06 08:23:18 +00:00
|
|
|
if (i > 0) {
|
2011-06-13 05:46:37 +00:00
|
|
|
final View divider = inflater.inflate(R.layout.candidate_divider, null);
|
2011-06-14 07:28:57 +00:00
|
|
|
divider.measure(UNSPECIFIED_MEASURESPEC, UNSPECIFIED_MEASURESPEC);
|
2011-06-06 08:23:18 +00:00
|
|
|
mDividers.add(divider);
|
|
|
|
}
|
2010-09-30 03:10:03 +00:00
|
|
|
}
|
2010-09-29 05:30:01 +00:00
|
|
|
|
2011-06-14 07:28:57 +00:00
|
|
|
mExpandCandidatesPane = findViewById(R.id.expand_candidates_pane);
|
|
|
|
mExpandCandidatesPane.setOnClickListener(new OnClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(View view) {
|
|
|
|
expandCandidatesPane();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
mCloseCandidatesPane = findViewById(R.id.close_candidates_pane);
|
|
|
|
mCloseCandidatesPane.setOnClickListener(new OnClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(View view) {
|
|
|
|
closeCandidatesPane();
|
|
|
|
}
|
|
|
|
});
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2010-09-30 03:10:03 +00:00
|
|
|
|
2009-03-13 22:11:42 +00:00
|
|
|
/**
|
2011-06-09 05:22:37 +00:00
|
|
|
* A connection back to the input method.
|
2009-03-13 22:11:42 +00:00
|
|
|
* @param listener
|
|
|
|
*/
|
2011-06-14 07:28:57 +00:00
|
|
|
public void setListener(Listener listener, View inputView) {
|
2011-06-09 05:22:37 +00:00
|
|
|
mListener = listener;
|
2011-06-14 07:28:57 +00:00
|
|
|
mKeyboardView = inputView.findViewById(R.id.keyboard_view);
|
|
|
|
mCandidatesPane = (ViewGroup)inputView.findViewById(R.id.candidates_pane);
|
|
|
|
mCandidatesPane.setOnClickListener(this);
|
|
|
|
mCandidatesPaneContainer = (ViewGroup)inputView.findViewById(
|
|
|
|
R.id.candidates_pane_container);
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
|
|
|
|
2010-12-10 11:50:30 +00:00
|
|
|
public void setSuggestions(SuggestedWords suggestions) {
|
2010-12-19 08:32:26 +00:00
|
|
|
if (suggestions == null)
|
2010-12-10 07:05:22 +00:00
|
|
|
return;
|
2010-12-19 08:32:26 +00:00
|
|
|
mSuggestions = suggestions;
|
2010-12-09 07:36:45 +00:00
|
|
|
if (mShowingAutoCorrectionInverted) {
|
2010-12-19 08:32:26 +00:00
|
|
|
mHandler.postUpdateSuggestions();
|
2010-12-09 07:36:45 +00:00
|
|
|
} else {
|
2010-12-19 08:32:26 +00:00
|
|
|
updateSuggestions();
|
2010-12-09 07:36:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-14 07:28:57 +00:00
|
|
|
private static void setLayoutWeight(View v, float weight) {
|
|
|
|
ViewGroup.LayoutParams lp = v.getLayoutParams();
|
|
|
|
if (lp instanceof LinearLayout.LayoutParams) {
|
|
|
|
LinearLayout.LayoutParams llp = (LinearLayout.LayoutParams)lp;
|
|
|
|
llp.width = 0;
|
|
|
|
llp.weight = weight;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-07 08:18:53 +00:00
|
|
|
private CharSequence getStyledCandidateWord(CharSequence word, boolean isAutoCorrect) {
|
|
|
|
if (!isAutoCorrect)
|
|
|
|
return word;
|
|
|
|
final CharacterStyle style = mConfigCandidateHighlightFontColorEnabled ? BOLD_SPAN
|
|
|
|
: UNDERLINE_SPAN;
|
|
|
|
final Spannable spannedWord = new SpannableString(word);
|
|
|
|
spannedWord.setSpan(style, 0, word.length(), Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
|
|
|
|
return spannedWord;
|
|
|
|
}
|
|
|
|
|
|
|
|
private int getCandidateTextColor(boolean isAutoCorrect, boolean isSuggestedCandidate,
|
|
|
|
SuggestedWordInfo info) {
|
|
|
|
final int color;
|
|
|
|
if (isAutoCorrect && mConfigCandidateHighlightFontColorEnabled) {
|
|
|
|
color = mColorAutoCorrect;
|
2011-06-13 05:46:37 +00:00
|
|
|
} else if (isSuggestedCandidate && mConfigCandidateHighlightFontColorEnabled) {
|
2011-06-07 08:18:53 +00:00
|
|
|
color = mColorSuggestedCandidate;
|
|
|
|
} else {
|
|
|
|
color = mColorTypedWord;
|
|
|
|
}
|
|
|
|
if (info != null && info.isPreviousSuggestedWord()) {
|
|
|
|
final int newAlpha = (int)(Color.alpha(color) * 0.5f);
|
|
|
|
return Color.argb(newAlpha, Color.red(color), Color.green(color), Color.blue(color));
|
|
|
|
} else {
|
|
|
|
return color;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-19 08:32:26 +00:00
|
|
|
private void updateSuggestions() {
|
|
|
|
final SuggestedWords suggestions = mSuggestions;
|
2011-06-07 08:18:53 +00:00
|
|
|
final List<SuggestedWordInfo> suggestedWordInfoList = suggestions.mSuggestedWordInfoList;
|
|
|
|
|
2010-12-06 12:26:38 +00:00
|
|
|
clear();
|
2011-06-14 07:28:57 +00:00
|
|
|
final int paneWidth = getWidth();
|
|
|
|
final int dividerWidth = mDividers.get(0).getMeasuredWidth();
|
|
|
|
int x = 0;
|
|
|
|
int y = 0;
|
|
|
|
int fromIndex = NUM_CANDIDATES_IN_STRIP;
|
2011-05-06 04:52:07 +00:00
|
|
|
final int count = Math.min(mWords.size(), suggestions.size());
|
2011-06-14 07:28:57 +00:00
|
|
|
closeCandidatesPane();
|
|
|
|
mExpandCandidatesPane.setEnabled(count >= NUM_CANDIDATES_IN_STRIP);
|
2009-03-13 22:11:42 +00:00
|
|
|
for (int i = 0; i < count; i++) {
|
2011-06-07 08:18:53 +00:00
|
|
|
final CharSequence word = suggestions.getWord(i);
|
2010-12-10 11:50:30 +00:00
|
|
|
if (word == null) continue;
|
2011-06-07 08:18:53 +00:00
|
|
|
|
|
|
|
final SuggestedWordInfo info = (suggestedWordInfoList != null)
|
|
|
|
? suggestedWordInfoList.get(i) : null;
|
|
|
|
final boolean isAutoCorrect = suggestions.mHasMinimalSuggestion
|
2011-01-18 08:22:01 +00:00
|
|
|
&& ((i == 1 && !suggestions.mTypedWordValid)
|
2011-06-07 08:18:53 +00:00
|
|
|
|| (i == 0 && suggestions.mTypedWordValid));
|
|
|
|
// HACK: even if i == 0, we use mColorOther when this suggestion's length is 1
|
|
|
|
// and there are multiple suggestions, such as the default punctuation list.
|
|
|
|
// TODO: Need to revisit this logic with bigram suggestions
|
|
|
|
final boolean isSuggestedCandidate = (i != 0);
|
|
|
|
final boolean isPunctuationSuggestions = (word.length() == 1 && count > 1);
|
|
|
|
|
|
|
|
final TextView tv = mWords.get(i);
|
2011-06-14 07:28:57 +00:00
|
|
|
// TODO: Reorder candidates in strip as appropriate. The center candidate should hold
|
|
|
|
// the word when space is typed (valid typed word or auto corrected word).
|
2011-06-07 08:18:53 +00:00
|
|
|
tv.setTextColor(getCandidateTextColor(isAutoCorrect,
|
|
|
|
isSuggestedCandidate || isPunctuationSuggestions, info));
|
|
|
|
tv.setText(getStyledCandidateWord(word, isAutoCorrect));
|
2011-06-14 07:28:57 +00:00
|
|
|
// TODO: call TextView.setTextScaleX() to fit the candidate in single line.
|
|
|
|
if (i >= NUM_CANDIDATES_IN_STRIP) {
|
|
|
|
tv.measure(UNSPECIFIED_MEASURESPEC, UNSPECIFIED_MEASURESPEC);
|
|
|
|
final int width = tv.getMeasuredWidth();
|
|
|
|
// TODO: Handle overflow case.
|
|
|
|
if (dividerWidth + x + width >= paneWidth) {
|
|
|
|
centeringCandidates(fromIndex, i - 1, x, paneWidth);
|
|
|
|
x = 0;
|
|
|
|
y += mCandidateStripHeight;
|
|
|
|
fromIndex = i;
|
|
|
|
}
|
|
|
|
if (x != 0) {
|
|
|
|
final View divider = mDividers.get(i - NUM_CANDIDATES_IN_STRIP);
|
|
|
|
mCandidatesPane.addView(divider);
|
|
|
|
placeCandidateAt(divider, x, y);
|
|
|
|
x += dividerWidth;
|
|
|
|
}
|
|
|
|
mCandidatesPane.addView(tv);
|
|
|
|
placeCandidateAt(tv, x, y);
|
|
|
|
x += width;
|
2010-12-10 11:50:30 +00:00
|
|
|
}
|
2011-06-07 08:18:53 +00:00
|
|
|
|
|
|
|
if (DBG && info != null) {
|
|
|
|
final TextView dv = new TextView(getContext(), null);
|
|
|
|
dv.setTextSize(10.0f);
|
|
|
|
dv.setTextColor(0xff808080);
|
|
|
|
dv.setText(info.getDebugString());
|
2011-06-14 07:28:57 +00:00
|
|
|
// TODO: debug view for candidate strip needed.
|
|
|
|
mCandidatesPane.addView(dv);
|
2011-06-07 08:18:53 +00:00
|
|
|
LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)dv.getLayoutParams();
|
|
|
|
lp.gravity = Gravity.BOTTOM;
|
|
|
|
}
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2011-06-14 07:28:57 +00:00
|
|
|
if (x != 0) {
|
|
|
|
// Centering last candidates row.
|
|
|
|
centeringCandidates(fromIndex, count - 1, x, paneWidth);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void placeCandidateAt(View v, int x, int y) {
|
|
|
|
ViewGroup.LayoutParams lp = v.getLayoutParams();
|
|
|
|
if (lp instanceof ViewGroup.MarginLayoutParams) {
|
|
|
|
ViewGroup.MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams)lp;
|
|
|
|
mlp.width = v.getMeasuredWidth();
|
|
|
|
mlp.height = v.getMeasuredHeight();
|
|
|
|
mlp.setMargins(x, y + (mCandidateStripHeight - mlp.height) / 2, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void centeringCandidates(int from, int to, int width, int paneWidth) {
|
|
|
|
final ViewGroup pane = mCandidatesPane;
|
|
|
|
final int fromIndex = pane.indexOfChild(mWords.get(from));
|
|
|
|
final int toIndex = pane.indexOfChild(mWords.get(to));
|
|
|
|
final int offset = (paneWidth - width) / 2;
|
|
|
|
for (int index = fromIndex; index <= toIndex; index++) {
|
|
|
|
offsetMargin(pane.getChildAt(index), offset, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private static void offsetMargin(View v, int dx, int dy) {
|
|
|
|
ViewGroup.LayoutParams lp = v.getLayoutParams();
|
|
|
|
if (lp instanceof ViewGroup.MarginLayoutParams) {
|
|
|
|
ViewGroup.MarginLayoutParams mlp = (ViewGroup.MarginLayoutParams)lp;
|
|
|
|
mlp.setMargins(mlp.leftMargin + dx, mlp.topMargin + dy, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private void expandCandidatesPane() {
|
|
|
|
mExpandCandidatesPane.setVisibility(View.GONE);
|
|
|
|
mCloseCandidatesPane.setVisibility(View.VISIBLE);
|
|
|
|
mCandidatesPaneContainer.setMinimumHeight(mKeyboardView.getMeasuredHeight());
|
|
|
|
mCandidatesPaneContainer.setVisibility(View.VISIBLE);
|
|
|
|
mKeyboardView.setVisibility(View.GONE);
|
|
|
|
}
|
2010-12-06 12:26:38 +00:00
|
|
|
|
2011-06-14 07:28:57 +00:00
|
|
|
private void closeCandidatesPane() {
|
|
|
|
mExpandCandidatesPane.setVisibility(View.VISIBLE);
|
|
|
|
mCloseCandidatesPane.setVisibility(View.GONE);
|
|
|
|
mCandidatesPaneContainer.setVisibility(View.GONE);
|
|
|
|
mKeyboardView.setVisibility(View.VISIBLE);
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
|
|
|
|
2010-12-09 07:36:45 +00:00
|
|
|
public void onAutoCorrectionInverted(CharSequence autoCorrectedWord) {
|
|
|
|
// Displaying auto corrected word as inverted is enabled only when highlighting candidate
|
|
|
|
// with color is disabled.
|
|
|
|
if (mConfigCandidateHighlightFontColorEnabled)
|
|
|
|
return;
|
2011-06-07 08:18:53 +00:00
|
|
|
final TextView tv = mWords.get(1);
|
2010-12-09 07:36:45 +00:00
|
|
|
final Spannable word = new SpannableString(autoCorrectedWord);
|
|
|
|
final int wordLength = word.length();
|
2011-01-31 05:49:33 +00:00
|
|
|
word.setSpan(mInvertedBackgroundColorSpan, 0, wordLength,
|
|
|
|
Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
|
|
|
|
word.setSpan(mInvertedForegroundColorSpan, 0, wordLength,
|
|
|
|
Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
|
2010-12-09 07:36:45 +00:00
|
|
|
tv.setText(word);
|
|
|
|
mShowingAutoCorrectionInverted = true;
|
|
|
|
}
|
|
|
|
|
2010-12-10 11:50:30 +00:00
|
|
|
public boolean isConfigCandidateHighlightFontColorEnabled() {
|
|
|
|
return mConfigCandidateHighlightFontColorEnabled;
|
|
|
|
}
|
|
|
|
|
2010-08-26 19:22:58 +00:00
|
|
|
public boolean isShowingAddToDictionaryHint() {
|
|
|
|
return mShowingAddToDictionary;
|
|
|
|
}
|
|
|
|
|
2010-02-11 01:45:35 +00:00
|
|
|
public void showAddToDictionaryHint(CharSequence word) {
|
2010-12-10 11:50:30 +00:00
|
|
|
SuggestedWords.Builder builder = new SuggestedWords.Builder()
|
|
|
|
.addWord(word)
|
|
|
|
.addWord(getContext().getText(R.string.hint_add_to_dictionary));
|
|
|
|
setSuggestions(builder.build());
|
2010-02-11 01:45:35 +00:00
|
|
|
mShowingAddToDictionary = true;
|
2010-12-06 12:26:38 +00:00
|
|
|
// Disable R.string.hint_add_to_dictionary button
|
2011-06-07 08:18:53 +00:00
|
|
|
TextView tv = mWords.get(1);
|
2010-12-06 12:26:38 +00:00
|
|
|
tv.setClickable(false);
|
2010-02-11 01:45:35 +00:00
|
|
|
}
|
|
|
|
|
2010-08-03 18:47:42 +00:00
|
|
|
public boolean dismissAddToDictionaryHint() {
|
|
|
|
if (!mShowingAddToDictionary) return false;
|
|
|
|
clear();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-12-10 11:50:30 +00:00
|
|
|
public SuggestedWords getSuggestions() {
|
2010-08-20 05:35:02 +00:00
|
|
|
return mSuggestions;
|
|
|
|
}
|
|
|
|
|
2009-03-13 22:11:42 +00:00
|
|
|
public void clear() {
|
2010-02-11 01:45:35 +00:00
|
|
|
mShowingAddToDictionary = false;
|
2010-12-09 07:36:45 +00:00
|
|
|
mShowingAutoCorrectionInverted = false;
|
2011-06-14 07:28:57 +00:00
|
|
|
for (int i = 0; i < NUM_CANDIDATES_IN_STRIP; i++)
|
|
|
|
mWords.get(i).setText(null);
|
|
|
|
mCandidatesPane.removeAllViews();
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
|
|
|
|
2009-03-31 21:50:26 +00:00
|
|
|
private void hidePreview() {
|
2010-09-29 05:30:01 +00:00
|
|
|
mPreviewPopup.dismiss();
|
2009-03-31 21:50:26 +00:00
|
|
|
}
|
2010-12-06 12:26:38 +00:00
|
|
|
|
|
|
|
private void showPreview(int index, CharSequence word) {
|
|
|
|
if (TextUtils.isEmpty(word))
|
|
|
|
return;
|
|
|
|
|
|
|
|
final TextView previewText = mPreviewText;
|
2011-06-07 08:18:53 +00:00
|
|
|
previewText.setTextColor(mColorTypedWord);
|
2010-12-06 12:26:38 +00:00
|
|
|
previewText.setText(word);
|
|
|
|
previewText.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
|
|
|
|
MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
|
2011-06-07 03:30:28 +00:00
|
|
|
View v = mWords.get(index);
|
2010-12-06 12:26:38 +00:00
|
|
|
final int[] offsetInWindow = new int[2];
|
|
|
|
v.getLocationInWindow(offsetInWindow);
|
|
|
|
final int posX = offsetInWindow[0];
|
|
|
|
final int posY = offsetInWindow[1] - previewText.getMeasuredHeight();
|
|
|
|
final PopupWindow previewPopup = mPreviewPopup;
|
|
|
|
if (previewPopup.isShowing()) {
|
|
|
|
previewPopup.update(posX, posY, previewPopup.getWidth(), previewPopup.getHeight());
|
|
|
|
} else {
|
|
|
|
previewPopup.showAtLocation(this, Gravity.NO_GRAVITY, posX, posY);
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2010-12-06 12:26:38 +00:00
|
|
|
previewText.setVisibility(VISIBLE);
|
2010-12-09 07:36:45 +00:00
|
|
|
mHandler.postHidePreview();
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2010-09-30 05:26:12 +00:00
|
|
|
|
2010-12-06 12:26:38 +00:00
|
|
|
private void addToDictionary(CharSequence word) {
|
2011-06-09 05:22:37 +00:00
|
|
|
if (mListener.addWordToDictionary(word.toString())) {
|
2010-12-06 12:26:38 +00:00
|
|
|
showPreview(0, getContext().getString(R.string.added_word, word));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public boolean onLongClick(View view) {
|
2011-06-14 07:28:57 +00:00
|
|
|
final Object tag = view.getTag();
|
|
|
|
if (!(tag instanceof Integer))
|
|
|
|
return true;
|
|
|
|
final int index = (Integer) tag;
|
2011-06-10 00:53:27 +00:00
|
|
|
if (index >= mSuggestions.size())
|
|
|
|
return true;
|
2011-06-14 07:28:57 +00:00
|
|
|
|
2011-06-10 00:53:27 +00:00
|
|
|
final CharSequence word = mSuggestions.getWord(index);
|
2010-12-06 12:26:38 +00:00
|
|
|
if (word.length() < 2)
|
|
|
|
return false;
|
|
|
|
addToDictionary(word);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onClick(View view) {
|
2011-06-14 07:28:57 +00:00
|
|
|
final Object tag = view.getTag();
|
|
|
|
if (!(tag instanceof Integer))
|
|
|
|
return;
|
|
|
|
final int index = (Integer) tag;
|
2011-06-10 00:53:27 +00:00
|
|
|
if (index >= mSuggestions.size())
|
|
|
|
return;
|
2011-06-14 07:28:57 +00:00
|
|
|
|
2011-06-10 00:53:27 +00:00
|
|
|
final CharSequence word = mSuggestions.getWord(index);
|
2010-12-06 12:26:38 +00:00
|
|
|
if (mShowingAddToDictionary && index == 0) {
|
|
|
|
addToDictionary(word);
|
|
|
|
} else {
|
2011-06-09 05:22:37 +00:00
|
|
|
mListener.pickSuggestionManually(index, word);
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2011-06-14 07:28:57 +00:00
|
|
|
// Because some punctuation letters are not treated as word separator depending on locale,
|
|
|
|
// {@link #setSuggestions} might not be called and candidates pane left opened.
|
|
|
|
closeCandidatesPane();
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|
2011-01-18 08:22:01 +00:00
|
|
|
|
2009-03-31 21:50:26 +00:00
|
|
|
@Override
|
|
|
|
public void onDetachedFromWindow() {
|
|
|
|
super.onDetachedFromWindow();
|
2010-12-09 07:36:45 +00:00
|
|
|
mHandler.cancelAllMessages();
|
2009-03-31 21:50:26 +00:00
|
|
|
hidePreview();
|
|
|
|
}
|
2009-03-13 22:11:42 +00:00
|
|
|
}
|