packages/inputmethods/LatinIME/java/src/com/android/inputmethod/latin/CandidateView.java

   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
  17 package com.android.inputmethod.latin;
  18
  19 import android.content.Context;
  20 import android.content.res.Resources;
  21 import android.graphics.Canvas;
  22 import android.graphics.Paint;
  23 import android.graphics.Paint.Align;
  24 import android.graphics.Rect;
  25 import android.graphics.Typeface;
  26 import android.graphics.drawable.Drawable;
  27 import android.util.AttributeSet;
  28 import android.view.GestureDetector;
  29 import android.view.Gravity;
  30 import android.view.LayoutInflater;
  31 import android.view.MotionEvent;
  32 import android.view.View;
  33 import android.view.ViewGroup.LayoutParams;
  34 import android.widget.PopupWindow;
  35 import android.widget.TextView;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.List;
  40
  41 public class CandidateView extends View {
  42
  43     private static final int OUT_OF_BOUNDS_WORD_INDEX = -1;
  44     private static final int OUT_OF_BOUNDS_X_COORD = -1;
  45
  46     private LatinIME mService;
  47     private final ArrayList<CharSequence> mSuggestions = new ArrayList<CharSequence>();
  48     private boolean mShowingCompletions;
  49     private CharSequence mSelectedString;
  50     private int mSelectedIndex;
  51     private int mTouchX = OUT_OF_BOUNDS_X_COORD;
  52     private final Drawable mSelectionHighlight;
  53     private boolean mTypedWordValid;
  54
  55     private boolean mHaveMinimalSuggestion;
  56
  57     private Rect mBgPadding;
  58
  59     private final TextView mPreviewText;
  60     private final PopupWindow mPreviewPopup;
  61     private int mCurrentWordIndex;
  62     private Drawable mDivider;
  63
  64     private static final int MAX_SUGGESTIONS = 32;
  65     private static final int SCROLL_PIXELS = 20;
  66
  67     private final int[] mWordWidth = new int[MAX_SUGGESTIONS];
  68     private final int[] mWordX = new int[MAX_SUGGESTIONS];
  69     private int mPopupPreviewX;
  70     private int mPopupPreviewY;
  71
  72     private static final int X_GAP = 10;
  73
  74     private final int mColorNormal;
  75     private final int mColorRecommended;
  76     private final int mColorOther;
  77     private final Paint mPaint;
  78     private final int mDescent;
  79     private boolean mScrolled;
  80     private boolean mShowingAddToDictionary;
  81     private CharSequence mAddToDictionaryHint;
  82
  83     private int mTargetScrollX;
  84
  85     private final int mMinTouchableWidth;
  86
  87     private int mTotalWidth;
  88
  89     private final GestureDetector mGestureDetector;
  90
  91     /**
  92      * Construct a CandidateView for showing suggested words for completion.
  93      * @param context
  94      * @param attrs
  95      */
  96     public CandidateView(Context context, AttributeSet attrs) {
  97         super(context, attrs);
  98         mSelectionHighlight = context.getResources().getDrawable(
  99                 R.drawable.list_selector_background_pressed);
 100
 101         LayoutInflater inflate =
 102             (LayoutInflater) context
 103                     .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
 104         Resources res = context.getResources();
 105         mPreviewPopup = new PopupWindow(context);
 106         mPreviewText = (TextView) inflate.inflate(R.layout.candidate_preview, null);
 107         mPreviewPopup.setWindowLayoutMode(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
 108         mPreviewPopup.setContentView(mPreviewText);
 109         mPreviewPopup.setBackgroundDrawable(null);
 110         mPreviewPopup.setAnimationStyle(R.style.KeyPreviewAnimation);
 111         mColorNormal = res.getColor(R.color.candidate_normal);
 112         mColorRecommended = res.getColor(R.color.candidate_recommended);
 113         mColorOther = res.getColor(R.color.candidate_other);
 114         mDivider = res.getDrawable(R.drawable.keyboard_suggest_strip_divider);
 115         mAddToDictionaryHint = res.getString(R.string.hint_add_to_dictionary);
 116
 117         mPaint = new Paint();
 118         mPaint.setColor(mColorNormal);
 119         mPaint.setAntiAlias(true);
 120         mPaint.setTextSize(mPreviewText.getTextSize());
 121         mPaint.setStrokeWidth(0);
 122         mPaint.setTextAlign(Align.CENTER);
 123         mDescent = (int) mPaint.descent();
 124         mMinTouchableWidth = (int)res.getDimension(R.dimen.candidate_min_touchable_width);
 125
 126         mGestureDetector = new GestureDetector(
 127                 new CandidateStripGestureListener(mMinTouchableWidth));
 128         setWillNotDraw(false);
 129         setHorizontalScrollBarEnabled(false);
 130         setVerticalScrollBarEnabled(false);
 131         scrollTo(0, getScrollY());
 132     }
 133
 134     private class CandidateStripGestureListener extends GestureDetector.SimpleOnGestureListener {
 135         private final int mTouchSlopSquare;
 136
 137         public CandidateStripGestureListener(int touchSlop) {
 138             // Slightly reluctant to scroll to be able to easily choose the suggestion
 139             mTouchSlopSquare = touchSlop * touchSlop;
 140         }
 141
 142         @Override
 143         public void onLongPress(MotionEvent me) {
 144             if (mSuggestions.size() > 0) {
 145                 if (me.getX() + getScrollX() < mWordWidth[0] && getScrollX() < 10) {
 146                     longPressFirstWord();
 147                 }
 148             }
 149         }
 150
 151         @Override
 152         public boolean onDown(MotionEvent e) {
 153             mScrolled = false;
 154             return false;
 155         }
 156
 157         @Override
 158         public boolean onScroll(MotionEvent e1, MotionEvent e2,
 159                 float distanceX, float distanceY) {
 160             if (!mScrolled) {
 161                 // This is applied only when we recognize that scrolling is starting.
 162                 final int deltaX = (int) (e2.getX() - e1.getX());
 163                 final int deltaY = (int) (e2.getY() - e1.getY());
 164                 final int distance = (deltaX * deltaX) + (deltaY * deltaY);
 165                 if (distance < mTouchSlopSquare) {
 166                     return true;
 167                 }
 168                 mScrolled = true;
 169             }
 170
 171             final int width = getWidth();
 172             mScrolled = true;
 173             int scrollX = getScrollX();
 174             scrollX += (int) distanceX;
 175             if (scrollX < 0) {
 176                 scrollX = 0;
 177             }
 178             if (distanceX > 0 && scrollX + width > mTotalWidth) {
 179                 scrollX -= (int) distanceX;
 180             }
 181             mTargetScrollX = scrollX;
 182             scrollTo(scrollX, getScrollY());
 183             hidePreview();
 184             invalidate();
 185             return true;
 186         }
 187     }
 188
 189     /**
 190      * A connection back to the service to communicate with the text field
 191      * @param listener
 192      */
 193     public void setService(LatinIME listener) {
 194         mService = listener;
 195     }
 196
 197     @Override
 198     public int computeHorizontalScrollRange() {
 199         return mTotalWidth;
 200     }
 201
 202     /**
 203      * If the canvas is null, then only touch calculations are performed to pick the target
 204      * candidate.
 205      */
 206     @Override
 207     protected void onDraw(Canvas canvas) {
 208         if (canvas != null) {
 209             super.onDraw(canvas);
 210         }
 211         mTotalWidth = 0;
 212
 213         final int height = getHeight();
 214         if (mBgPadding == null) {
 215             mBgPadding = new Rect(0, 0, 0, 0);
 216             if (getBackground() != null) {
 217                 getBackground().getPadding(mBgPadding);
 218             }
 219             mDivider.setBounds(0, 0, mDivider.getIntrinsicWidth(),
 220                     mDivider.getIntrinsicHeight());
 221         }
 222
 223         final int count = mSuggestions.size();
 224         final Rect bgPadding = mBgPadding;
 225         final Paint paint = mPaint;
 226         final int touchX = mTouchX;
 227         final int scrollX = getScrollX();
 228         final boolean scrolled = mScrolled;
 229         final boolean typedWordValid = mTypedWordValid;
 230         final int y = (int) (height + mPaint.getTextSize() - mDescent) / 2;
 231
 232         boolean existsAutoCompletion = false;
 233
 234         int x = 0;
 235         for (int i = 0; i < count; i++) {
 236             CharSequence suggestion = mSuggestions.get(i);
 237             if (suggestion == null) continue;
 238             final int wordLength = suggestion.length();
 239
 240             paint.setColor(mColorNormal);
 241             if (mHaveMinimalSuggestion
 242                     && ((i == 1 && !typedWordValid) || (i == 0 && typedWordValid))) {
 243                 paint.setTypeface(Typeface.DEFAULT_BOLD);
 244                 paint.setColor(mColorRecommended);
 245                 existsAutoCompletion = true;
 246             } else if (i != 0 || (wordLength == 1 && count > 1)) {
 247                 // HACK: even if i == 0, we use mColorOther when this suggestion's length is 1 and
 248                 // there are multiple suggestions, such as the default punctuation list.
 249                 paint.setColor(mColorOther);
 250             }
 251             int wordWidth;
 252             if ((wordWidth = mWordWidth[i]) == 0) {
 253                 float textWidth =  paint.measureText(suggestion, 0, wordLength);
 254                 wordWidth = Math.max(mMinTouchableWidth, (int) textWidth + X_GAP * 2);
 255                 mWordWidth[i] = wordWidth;
 256             }
 257
 258             mWordX[i] = x;
 259
 260             if (touchX != OUT_OF_BOUNDS_X_COORD && !scrolled
 261                     && touchX + scrollX >= x && touchX + scrollX < x + wordWidth) {
 262                 if (canvas != null && !mShowingAddToDictionary) {
 263                     canvas.translate(x, 0);
 264                     mSelectionHighlight.setBounds(0, bgPadding.top, wordWidth, height);
 265                     mSelectionHighlight.draw(canvas);
 266                     canvas.translate(-x, 0);
 267                 }
 268                 mSelectedString = suggestion;
 269                 mSelectedIndex = i;
 270             }
 271
 272             if (canvas != null) {
 273                 canvas.drawText(suggestion, 0, wordLength, x + wordWidth / 2, y, paint);
 274                 paint.setColor(mColorOther);
 275                 canvas.translate(x + wordWidth, 0);
 276                 // Draw a divider unless it's after the hint
 277                 if (!(mShowingAddToDictionary && i == 1)) {
 278                     mDivider.draw(canvas);
 279                 }
 280                 canvas.translate(-x - wordWidth, 0);
 281             }
 282             paint.setTypeface(Typeface.DEFAULT);
 283             x += wordWidth;
 284         }
 285         mService.onAutoCompletionStateChanged(existsAutoCompletion);
 286         mTotalWidth = x;
 287         if (mTargetScrollX != scrollX) {
 288             scrollToTarget();
 289         }
 290     }
 291
 292     private void scrollToTarget() {
 293         int scrollX = getScrollX();
 294         if (mTargetScrollX > scrollX) {
 295             scrollX += SCROLL_PIXELS;
 296             if (scrollX >= mTargetScrollX) {
 297                 scrollX = mTargetScrollX;
 298                 scrollTo(scrollX, getScrollY());
 299                 requestLayout();
 300             } else {
 301                 scrollTo(scrollX, getScrollY());
 302             }
 303         } else {
 304             scrollX -= SCROLL_PIXELS;
 305             if (scrollX <= mTargetScrollX) {
 306                 scrollX = mTargetScrollX;
 307                 scrollTo(scrollX, getScrollY());
 308                 requestLayout();
 309             } else {
 310                 scrollTo(scrollX, getScrollY());
 311             }
 312         }
 313         invalidate();
 314     }
 315
 316     public void setSuggestions(List<CharSequence> suggestions, boolean completions,
 317             boolean typedWordValid, boolean haveMinimalSuggestion) {
 318         clear();
 319         if (suggestions != null) {
 320             int insertCount = Math.min(suggestions.size(), MAX_SUGGESTIONS);
 321             for (CharSequence suggestion : suggestions) {
 322                 mSuggestions.add(suggestion);
 323                 if (--insertCount == 0)
 324                     break;
 325             }
 326         }
 327         mShowingCompletions = completions;
 328         mTypedWordValid = typedWordValid;
 329         scrollTo(0, getScrollY());
 330         mTargetScrollX = 0;
 331         mHaveMinimalSuggestion = haveMinimalSuggestion;
 332         // Compute the total width
 333         onDraw(null);
 334         invalidate();
 335         requestLayout();
 336     }
 337
 338     public boolean isShowingAddToDictionaryHint() {
 339         return mShowingAddToDictionary;
 340     }
 341
 342     public void showAddToDictionaryHint(CharSequence word) {
 343         ArrayList<CharSequence> suggestions = new ArrayList<CharSequence>();
 344         suggestions.add(word);
 345         suggestions.add(mAddToDictionaryHint);
 346         setSuggestions(suggestions, false, false, false);
 347         mShowingAddToDictionary = true;
 348     }
 349
 350     public boolean dismissAddToDictionaryHint() {
 351         if (!mShowingAddToDictionary) return false;
 352         clear();
 353         return true;
 354     }
 355
 356     /* package */ List<CharSequence> getSuggestions() {
 357         return mSuggestions;
 358     }
 359
 360     public void clear() {
 361         // Don't call mSuggestions.clear() because it's being used for logging
 362         // in LatinIME.pickSuggestionManually().
 363         mSuggestions.clear();
 364         mTouchX = OUT_OF_BOUNDS_X_COORD;
 365         mSelectedString = null;
 366         mSelectedIndex = -1;
 367         mShowingAddToDictionary = false;
 368         invalidate();
 369         Arrays.fill(mWordWidth, 0);
 370         Arrays.fill(mWordX, 0);
 371     }
 372
 373     @Override
 374     public boolean onTouchEvent(MotionEvent me) {
 375
 376         if (mGestureDetector.onTouchEvent(me)) {
 377             return true;
 378         }
 379
 380         int action = me.getAction();
 381         int x = (int) me.getX();
 382         int y = (int) me.getY();
 383         mTouchX = x;
 384
 385         switch (action) {
 386         case MotionEvent.ACTION_DOWN:
 387             invalidate();
 388             break;
 389         case MotionEvent.ACTION_MOVE:
 390             if (y <= 0) {
 391                 // Fling up!?
 392                 if (mSelectedString != null) {
 393                     // If there are completions from the application, we don't change the state to
 394                     // STATE_PICKED_SUGGESTION
 395                     if (!mShowingCompletions) {
 396                         // This "acceptedSuggestion" will not be counted as a word because
 397                         // it will be counted in pickSuggestion instead.
 398                         TextEntryState.acceptedSuggestion(mSuggestions.get(0),
 399                                 mSelectedString);
 400                     }
 401                     mService.pickSuggestionManually(mSelectedIndex, mSelectedString);
 402                     mSelectedString = null;
 403                     mSelectedIndex = -1;
 404                 }
 405             }
 406             break;
 407         case MotionEvent.ACTION_UP:
 408             if (!mScrolled) {
 409                 if (mSelectedString != null) {
 410                     if (mShowingAddToDictionary) {
 411                         longPressFirstWord();
 412                         clear();
 413                     } else {
 414                         if (!mShowingCompletions) {
 415                             TextEntryState.acceptedSuggestion(mSuggestions.get(0),
 416                                     mSelectedString);
 417                         }
 418                         mService.pickSuggestionManually(mSelectedIndex, mSelectedString);
 419                     }
 420                 }
 421             }
 422             mSelectedString = null;
 423             mSelectedIndex = -1;
 424             requestLayout();
 425             hidePreview();
 426             invalidate();
 427             break;
 428         }
 429         return true;
 430     }
 431
 432     private void hidePreview() {
 433         mTouchX = OUT_OF_BOUNDS_X_COORD;
 434         mCurrentWordIndex = OUT_OF_BOUNDS_WORD_INDEX;
 435         mPreviewPopup.dismiss();
 436     }
 437
 438     private void showPreview(int wordIndex, String altText) {
 439         int oldWordIndex = mCurrentWordIndex;
 440         mCurrentWordIndex = wordIndex;
 441         // If index changed or changing text
 442         if (oldWordIndex != mCurrentWordIndex || altText != null) {
 443             if (wordIndex == OUT_OF_BOUNDS_WORD_INDEX) {
 444                 hidePreview();
 445             } else {
 446                 CharSequence word = altText != null? altText : mSuggestions.get(wordIndex);
 447                 mPreviewText.setText(word);
 448                 mPreviewText.measure(MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
 449                         MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
 450                 int wordWidth = (int) (mPaint.measureText(word, 0, word.length()) + X_GAP * 2);
 451                 final int popupWidth = wordWidth
 452                         + mPreviewText.getPaddingLeft() + mPreviewText.getPaddingRight();
 453                 final int popupHeight = mPreviewText.getMeasuredHeight();
 454                 //mPreviewText.setVisibility(INVISIBLE);
 455                 mPopupPreviewX = mWordX[wordIndex] - mPreviewText.getPaddingLeft() - getScrollX()
 456                         + (mWordWidth[wordIndex] - wordWidth) / 2;
 457                 mPopupPreviewY = - popupHeight;
 458                 int [] offsetInWindow = new int[2];
 459                 getLocationInWindow(offsetInWindow);
 460                 if (mPreviewPopup.isShowing()) {
 461                     mPreviewPopup.update(mPopupPreviewX, mPopupPreviewY + offsetInWindow[1],
 462                             popupWidth, popupHeight);
 463                 } else {
 464                     mPreviewPopup.setWidth(popupWidth);
 465                     mPreviewPopup.setHeight(popupHeight);
 466                     mPreviewPopup.showAtLocation(this, Gravity.NO_GRAVITY, mPopupPreviewX,
 467                             mPopupPreviewY + offsetInWindow[1]);
 468                 }
 469                 mPreviewText.setVisibility(VISIBLE);
 470             }
 471         }
 472     }
 473
 474     private void longPressFirstWord() {
 475         CharSequence word = mSuggestions.get(0);
 476         if (word.length() < 2) return;
 477         if (mService.addWordToDictionary(word.toString())) {
 478             showPreview(0, getContext().getResources().getString(R.string.added_word, word));
 479         }
 480     }
 481
 482     @Override
 483     public void onDetachedFromWindow() {
 484         super.onDetachedFromWindow();
 485         hidePreview();
 486     }
 487 }