| /* |
| * Copyright (C) 2008-2012 OMRON SOFTWARE Co., Ltd. |
| * |
| * 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 |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * 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 jp.co.omronsoft.openwnn; |
| |
| import java.nio.channels.Selector; |
| import java.util.ArrayList; |
| import java.util.LinkedList; |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.content.res.Resources; |
| import android.content.res.Configuration; |
| import android.graphics.drawable.Drawable; |
| import android.graphics.Rect; |
| import android.media.AudioManager; |
| import android.os.Handler; |
| import android.os.Message; |
| import android.os.Vibrator; |
| import android.preference.PreferenceManager; |
| import android.text.TextUtils; |
| import android.text.TextPaint; |
| import android.text.SpannableString; |
| import android.text.Spanned; |
| import android.text.style.ImageSpan; |
| import android.text.style.DynamicDrawableSpan; |
| import android.util.Log; |
| import android.util.DisplayMetrics; |
| import android.util.TypedValue; |
| import android.view.Gravity; |
| import android.view.KeyEvent; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.View.OnClickListener; |
| import android.view.View.OnLongClickListener; |
| import android.view.GestureDetector; |
| import android.view.LayoutInflater; |
| import android.widget.Button; |
| import android.widget.LinearLayout; |
| import android.widget.ScrollView; |
| import android.widget.TextView; |
| import android.widget.EditText; |
| import android.widget.AbsoluteLayout; |
| import android.widget.ImageView; |
| |
| /** |
| * The default candidates view manager class using {@link EditText}. |
| * |
| * @author Copyright (C) 2009-2011 OMRON SOFTWARE CO., LTD. All Rights Reserved. |
| */ |
| public class TextCandidatesViewManager extends CandidatesViewManager implements GestureDetector.OnGestureListener { |
| /** Number of lines to display (Portrait) */ |
| public static final int LINE_NUM_PORTRAIT = 2; |
| /** Number of lines to display (Landscape) */ |
| public static final int LINE_NUM_LANDSCAPE = 1; |
| |
| /** Maximum lines */ |
| private static final int DISPLAY_LINE_MAX_COUNT = 1000; |
| /** Maximum number of displaying candidates par one line (full view mode) */ |
| private static final int FULL_VIEW_DIV = 4; |
| /** Maximum number of displaying candidates par one line (full view mode)(symbol)(portrait) */ |
| private static final int FULL_VIEW_SYMBOL_DIV_PORT = 6; |
| /** Maximum number of displaying candidates par one line (full view mode)(symbol)(landscape) */ |
| private static final int FULL_VIEW_SYMBOL_DIV_LAND = 10; |
| /** Delay of set candidate */ |
| private static final int SET_CANDIDATE_DELAY = 50; |
| /** First line count */ |
| private static final int SET_CANDIDATE_FIRST_LINE_COUNT = 7; |
| /** Delay line count */ |
| private static final int SET_CANDIDATE_DELAY_LINE_COUNT = 1; |
| |
| /** Focus is none now */ |
| private static final int FOCUS_NONE = -1; |
| /** Handler for focus Candidate */ |
| private static final int MSG_MOVE_FOCUS = 0; |
| /** Handler for set Candidate */ |
| private static final int MSG_SET_CANDIDATES = 1; |
| /** Handler for select Candidate */ |
| private static final int MSG_SELECT_CANDIDATES = 2; |
| |
| /** NUmber of Candidate display lines */ |
| private static final int SETTING_NUMBER_OF_LINEMAX = 5; |
| |
| /** Body view of the candidates list */ |
| private ViewGroup mViewBody = null; |
| |
| /** The view of the Symbol Tab */ |
| private TextView mViewTabSymbol; |
| /** The view of the Emoticon Tab */ |
| private TextView mViewTabEmoticon; |
| /** Scroller of {@code mViewBodyText} */ |
| private ScrollView mViewBodyScroll; |
| /** Base of {@code mViewCandidateList1st}, {@code mViewCandidateList2nd} */ |
| private ViewGroup mViewCandidateBase; |
| /** Button displayed bottom of the view when there are more candidates. */ |
| private ImageView mReadMoreButton; |
| /** Layout for the candidates list on normal view */ |
| private LinearLayout mViewCandidateList1st; |
| /** Layout for the candidates list on full view */ |
| private AbsoluteLayout mViewCandidateList2nd; |
| /** View for symbol tab */ |
| private LinearLayout mViewCandidateListTab; |
| /** {@link OpenWnn} instance using this manager */ |
| private OpenWnn mWnn; |
| /** View type (VIEW_TYPE_NORMAL or VIEW_TYPE_FULL or VIEW_TYPE_CLOSE) */ |
| private int mViewType; |
| /** Portrait display({@code true}) or landscape({@code false}) */ |
| private boolean mPortrait; |
| |
| /** Width of the view */ |
| private int mViewWidth; |
| /** Minimum width of a candidate (density support) */ |
| private int mCandidateMinimumWidth; |
| /** Maximum width of a candidate (density support) */ |
| private int mCandidateMinimumHeight; |
| /** Minimum height of the category candidate view */ |
| private int mCandidateCategoryMinimumHeight; |
| /** Left align threshold of the candidate view */ |
| private int mCandidateLeftAlignThreshold; |
| /** Height of keyboard */ |
| private int mKeyboardHeight; |
| /** Height of symbol keyboard */ |
| private int mSymbolKeyboardHeight; |
| /** Height of symbol keyboard tab */ |
| private int mSymbolKeyboardTabHeight; |
| /** Whether being able to use Emoticon */ |
| private boolean mEnableEmoticon = false; |
| |
| /** Whether hide the view if there is no candidate */ |
| private boolean mAutoHideMode = true; |
| /** The converter to get candidates from and notice the selected candidate to. */ |
| private WnnEngine mConverter; |
| /** Limitation of displaying candidates */ |
| private int mDisplayLimit; |
| |
| /** Vibrator for touch vibration */ |
| private Vibrator mVibrator = null; |
| /** AudioManager for click sound */ |
| private AudioManager mSound = null; |
| |
| /** Number of candidates displaying for 1st */ |
| private int mWordCount1st; |
| /** Number of candidates displaying for 2nd */ |
| private int mWordCount2nd; |
| /** List of candidates for 1st */ |
| private ArrayList<WnnWord> mWnnWordArray1st = new ArrayList<WnnWord>(); |
| /** List of candidates for 2nd */ |
| private ArrayList<WnnWord> mWnnWordArray2nd = new ArrayList<WnnWord>(); |
| /** List of select candidates */ |
| private LinkedList<WnnWord> mWnnWordSelectedList = new LinkedList<WnnWord>(); |
| |
| /** Gesture detector */ |
| private GestureDetector mGestureDetector; |
| /** Character width of the candidate area */ |
| private int mLineLength = 0; |
| /** Number of lines displayed */ |
| private int mLineCount = 1; |
| |
| /** {@code true} if the full screen mode is selected */ |
| private boolean mIsFullView = false; |
| |
| /** The event object for "touch" */ |
| private MotionEvent mMotionEvent = null; |
| |
| /** The offset when the candidates is flowed out the candidate window */ |
| private int mDisplayEndOffset = 0; |
| /** {@code true} if there are more candidates to display. */ |
| private boolean mCanReadMore = false; |
| /** Color of the candidates */ |
| private int mTextColor = 0; |
| /** Template object for each candidate and normal/full view change button */ |
| private TextView mViewCandidateTemplate; |
| /** Number of candidates in full view */ |
| private int mFullViewWordCount; |
| /** Number of candidates in the current line (in full view) */ |
| private int mFullViewOccupyCount; |
| /** View of the previous candidate (in full view) */ |
| private TextView mFullViewPrevView; |
| /** Id of the top line view (in full view) */ |
| private int mFullViewPrevLineTopId; |
| /** Layout of the previous candidate (in full view) */ |
| private ViewGroup.LayoutParams mFullViewPrevParams; |
| /** Whether all candidates are displayed */ |
| private boolean mCreateCandidateDone; |
| /** Number of lines in normal view */ |
| private int mNormalViewWordCountOfLine; |
| |
| /** List of textView for CandiData List 1st for Symbol mode */ |
| private ArrayList<TextView> mTextViewArray1st = new ArrayList<TextView>(); |
| /** List of textView for CandiData List 2st for Symbol mode */ |
| private ArrayList<TextView> mTextViewArray2nd = new ArrayList<TextView>(); |
| /** Now focus textView index */ |
| private int mCurrentFocusIndex = FOCUS_NONE; |
| /** Focused View */ |
| private View mFocusedView = null; |
| /** Focused View Background */ |
| private Drawable mFocusedViewBackground = null; |
| /** Axis to find next TextView for Up/Down */ |
| private int mFocusAxisX = 0; |
| /** Now focused TextView in mTextViewArray1st */ |
| private boolean mHasFocusedArray1st = true; |
| |
| /** Portrait Number of Lines from Preference */ |
| private int mPortraitNumberOfLine = LINE_NUM_PORTRAIT; |
| /** Landscape Number of Lines from Preference */ |
| private int mLandscapeNumberOfLine = LINE_NUM_LANDSCAPE; |
| |
| /** Coordinates of line */ |
| private int mLineY = 0; |
| |
| /** {@code true} if the candidate is selected */ |
| private boolean mIsSymbolSelected = false; |
| |
| /** Whether candidates is symbol */ |
| private boolean mIsSymbolMode = false; |
| |
| /** Symbol mode */ |
| private int mSymbolMode = OpenWnnJAJP.ENGINE_MODE_SYMBOL; |
| |
| /** Text size of candidates */ |
| private float mCandNormalTextSize; |
| |
| /** Text size of category */ |
| private float mCandCategoryTextSize; |
| |
| /** HardKeyboard hidden({@code true}) or disp({@code false}) */ |
| private boolean mHardKeyboardHidden = true; |
| |
| /** Minimum height of the candidate 1line view */ |
| private int mCandidateOneLineMinimumHeight; |
| |
| /** Whether candidates long click enable */ |
| private boolean mEnableCandidateLongClick = true; |
| |
| /** Keyboard vertical gap value */ |
| private static final float KEYBOARD_VERTICAL_GAP = 0.009f; |
| |
| /** Keyboard vertical gap count */ |
| private static final int KEYBOARD_VERTICAL_GAP_COUNT = 3; |
| |
| /** {@code Handler} Handler for focus Candidate wait delay */ |
| private Handler mHandler = new Handler() { |
| @Override public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_MOVE_FOCUS: |
| moveFocus(msg.arg1, msg.arg2 == 1); |
| break; |
| |
| case MSG_SET_CANDIDATES: |
| if (mViewType == CandidatesViewManager.VIEW_TYPE_FULL && mIsSymbolMode) { |
| displayCandidates(mConverter, false, SET_CANDIDATE_DELAY_LINE_COUNT); |
| } |
| break; |
| |
| case MSG_SELECT_CANDIDATES: |
| WnnWord word = null; |
| while ((word = mWnnWordSelectedList.poll()) != null) { |
| selectCandidate(word); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| }; |
| |
| /** Event listener for touching a candidate for 1st */ |
| private OnClickListener mCandidateOnClick1st = new OnClickListener() { |
| public void onClick(View v) { |
| onClickCandidate(v, mWnnWordArray1st); |
| } |
| }; |
| |
| /** Event listener for touching a candidate for 2nd */ |
| private OnClickListener mCandidateOnClick2nd = new OnClickListener() { |
| public void onClick(View v) { |
| onClickCandidate(v, mWnnWordArray2nd); |
| } |
| }; |
| |
| /** Event listener for long-clicking a candidate for 1st */ |
| private OnLongClickListener mCandidateOnLongClick1st = new OnLongClickListener() { |
| public boolean onLongClick(View v) { |
| return onLongClickCandidate(v, mWnnWordArray1st); |
| } |
| }; |
| |
| /** Event listener for long-clicking a candidate for for 2nd */ |
| private OnLongClickListener mCandidateOnLongClick2nd = new OnLongClickListener() { |
| public boolean onLongClick(View v) { |
| return onLongClickCandidate(v, mWnnWordArray2nd); |
| } |
| }; |
| |
| /** Event listener for click a symbol tab */ |
| private OnClickListener mTabOnClick = new OnClickListener() { |
| public void onClick(View v) { |
| if (!v.isShown()) { |
| return; |
| } |
| playSoundAndVibration(); |
| |
| if (v instanceof TextView) { |
| TextView text = (TextView)v; |
| switch (text.getId()) { |
| case R.id.candview_symbol: |
| if (mSymbolMode != OpenWnnJAJP.ENGINE_MODE_SYMBOL) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_SYMBOL)); |
| } |
| break; |
| |
| case R.id.candview_emoticon: |
| if (mSymbolMode != OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_SYMBOL)); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| }; |
| |
| /** |
| * Constructor |
| */ |
| public TextCandidatesViewManager() { |
| this(-1); |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param displayLimit The limit of display |
| */ |
| public TextCandidatesViewManager(int displayLimit) { |
| mDisplayLimit = displayLimit; |
| } |
| |
| /** |
| * Handle a click event on the candidate. |
| * @param v View |
| * @param list List of candidates |
| */ |
| private void onClickCandidate(View v, ArrayList<WnnWord> list) { |
| if (!v.isShown()) { |
| return; |
| } |
| playSoundAndVibration(); |
| |
| if (v instanceof TextView) { |
| TextView text = (TextView)v; |
| int wordcount = text.getId(); |
| WnnWord word = list.get(wordcount); |
| |
| if (mHandler.hasMessages(MSG_SET_CANDIDATES)) { |
| mWnnWordSelectedList.add(word); |
| return; |
| } |
| clearFocusCandidate(); |
| selectCandidate(word); |
| } |
| } |
| |
| /** |
| * Handle a long click event on the candidate. |
| * @param v View |
| * @param list List of candidates |
| */ |
| public boolean onLongClickCandidate(View v, ArrayList<WnnWord> list) { |
| if (mViewLongPressDialog == null) { |
| return false; |
| } |
| |
| if (mIsSymbolMode) { |
| return false; |
| } |
| |
| if (!mEnableCandidateLongClick) { |
| return false; |
| } |
| |
| if (!v.isShown()) { |
| return true; |
| } |
| |
| Drawable d = v.getBackground(); |
| if (d != null) { |
| if(d.getState().length == 0){ |
| return true; |
| } |
| } |
| |
| int wordcount = ((TextView)v).getId(); |
| mWord = list.get(wordcount); |
| clearFocusCandidate(); |
| displayDialog(v, mWord); |
| |
| return true; |
| } |
| |
| /** |
| * Set auto-hide mode. |
| * @param hide {@code true} if the view will hidden when no candidate exists; |
| * {@code false} if the view is always shown. |
| */ |
| public void setAutoHide(boolean hide) { |
| mAutoHideMode = hide; |
| } |
| |
| /** @see CandidatesViewManager#initView */ |
| public View initView(OpenWnn parent, int width, int height) { |
| mWnn = parent; |
| mViewWidth = width; |
| Resources r = mWnn.getResources(); |
| mCandidateMinimumWidth = r.getDimensionPixelSize(R.dimen.cand_minimum_width); |
| mCandidateMinimumHeight = r.getDimensionPixelSize(R.dimen.cand_minimum_height); |
| if (OpenWnn.isXLarge()) { |
| mCandidateOneLineMinimumHeight = r.getDimensionPixelSize(R.dimen.candidate_layout_height); |
| } |
| mCandidateCategoryMinimumHeight = r.getDimensionPixelSize(R.dimen.cand_category_minimum_height); |
| mCandidateLeftAlignThreshold = r.getDimensionPixelSize(R.dimen.cand_left_align_threshold); |
| mKeyboardHeight = r.getDimensionPixelSize(R.dimen.keyboard_height); |
| if (OpenWnn.isXLarge()) { |
| mKeyboardHeight += Math.round(height * KEYBOARD_VERTICAL_GAP) |
| * KEYBOARD_VERTICAL_GAP_COUNT; |
| } |
| mSymbolKeyboardHeight = r.getDimensionPixelSize(R.dimen.symbol_keyboard_height); |
| Drawable d = r.getDrawable(R.drawable.tab_no_select); |
| mSymbolKeyboardTabHeight = d.getMinimumHeight(); |
| |
| mPortrait = |
| (r.getConfiguration().orientation != Configuration.ORIENTATION_LANDSCAPE); |
| |
| mCandNormalTextSize = r.getDimensionPixelSize(R.dimen.cand_normal_text_size); |
| mCandCategoryTextSize = r.getDimensionPixelSize(R.dimen.cand_category_text_size); |
| |
| LayoutInflater inflater = parent.getLayoutInflater(); |
| mViewBody = (ViewGroup)inflater.inflate(R.layout.candidates, null); |
| |
| mViewTabSymbol = (TextView)mViewBody.findViewById(R.id.candview_symbol); |
| mViewTabEmoticon = (TextView)mViewBody.findViewById(R.id.candview_emoticon); |
| |
| mViewBodyScroll = (ScrollView)mViewBody.findViewById(R.id.candview_scroll); |
| |
| mViewCandidateBase = (ViewGroup)mViewBody.findViewById(R.id.candview_base); |
| |
| setNumeberOfDisplayLines(); |
| createNormalCandidateView(); |
| mViewCandidateList2nd = (AbsoluteLayout)mViewBody.findViewById(R.id.candidates_2nd_view); |
| |
| mTextColor = r.getColor(R.color.candidate_text); |
| |
| mReadMoreButton = (ImageView)mViewBody.findViewById(R.id.read_more_button); |
| mReadMoreButton.setOnTouchListener(new View.OnTouchListener() { |
| public boolean onTouch(View v, MotionEvent event) { |
| int resid = 0; |
| switch (event.getAction()) { |
| case MotionEvent.ACTION_DOWN: |
| if (mIsFullView) { |
| resid = R.drawable.cand_up_press; |
| } else { |
| resid = R.drawable.cand_down_press; |
| } |
| break; |
| case MotionEvent.ACTION_UP: |
| if (mIsFullView) { |
| resid = R.drawable.cand_up; |
| } else { |
| resid = R.drawable.cand_down; |
| } |
| break; |
| default: |
| break; |
| } |
| |
| if (resid != 0) { |
| mReadMoreButton.setImageResource(resid); |
| } |
| return false; |
| } |
| }); |
| mReadMoreButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| if (!v.isShown()) { |
| return; |
| } |
| playSoundAndVibration(); |
| |
| if (mIsFullView) { |
| mIsFullView = false; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| } else { |
| mIsFullView = true; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_FULL)); |
| } |
| } |
| }); |
| |
| setViewType(CandidatesViewManager.VIEW_TYPE_CLOSE); |
| |
| mGestureDetector = new GestureDetector(this); |
| |
| mViewLongPressDialog = (View)inflater.inflate(R.layout.candidate_longpress_dialog, null); |
| |
| /* select button */ |
| Button longPressDialogButton = (Button)mViewLongPressDialog.findViewById(R.id.candidate_longpress_dialog_select); |
| longPressDialogButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| playSoundAndVibration(); |
| clearFocusCandidate(); |
| selectCandidate(mWord); |
| closeDialog(); |
| } |
| }); |
| |
| /* cancel button */ |
| longPressDialogButton = (Button)mViewLongPressDialog.findViewById(R.id.candidate_longpress_dialog_cancel); |
| longPressDialogButton.setOnClickListener(new View.OnClickListener() { |
| public void onClick(View v) { |
| playSoundAndVibration(); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.UPDATE_CANDIDATE)); |
| closeDialog(); |
| } |
| }); |
| |
| return mViewBody; |
| } |
| |
| /** |
| * Create the normal candidate view |
| */ |
| private void createNormalCandidateView() { |
| mViewCandidateList1st = (LinearLayout)mViewBody.findViewById(R.id.candidates_1st_view); |
| mViewCandidateList1st.setOnClickListener(mCandidateOnClick1st); |
| |
| mViewCandidateListTab = (LinearLayout)mViewBody.findViewById(R.id.candview_tab); |
| TextView tSymbol = mViewTabSymbol; |
| tSymbol.setOnClickListener(mTabOnClick); |
| TextView tEmoticon = mViewTabEmoticon; |
| tEmoticon.setOnClickListener(mTabOnClick); |
| |
| int line = SETTING_NUMBER_OF_LINEMAX; |
| int width = mViewWidth; |
| for (int i = 0; i < line; i++) { |
| LinearLayout lineView = new LinearLayout(mViewBodyScroll.getContext()); |
| lineView.setOrientation(LinearLayout.HORIZONTAL); |
| LinearLayout.LayoutParams layoutParams = |
| new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT); |
| lineView.setLayoutParams(layoutParams); |
| for (int j = 0; j < (width / getCandidateMinimumWidth()); j++) { |
| TextView tv = createCandidateView(); |
| lineView.addView(tv); |
| } |
| |
| if (i == 0) { |
| TextView tv = createCandidateView(); |
| layoutParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT); |
| layoutParams.weight = 0; |
| layoutParams.gravity = Gravity.RIGHT; |
| tv.setLayoutParams(layoutParams); |
| |
| lineView.addView(tv); |
| mViewCandidateTemplate = tv; |
| } |
| mViewCandidateList1st.addView(lineView); |
| } |
| } |
| |
| /** @see CandidatesViewManager#getCurrentView */ |
| public View getCurrentView() { |
| return mViewBody; |
| } |
| |
| /** @see CandidatesViewManager#setViewType */ |
| public void setViewType(int type) { |
| boolean readMore = setViewLayout(type); |
| |
| if (readMore) { |
| displayCandidates(this.mConverter, false, -1); |
| } else { |
| if (type == CandidatesViewManager.VIEW_TYPE_NORMAL) { |
| mIsFullView = false; |
| if (mDisplayEndOffset > 0) { |
| int maxLine = getMaxLine(); |
| displayCandidates(this.mConverter, false, maxLine); |
| } else { |
| setReadMore(); |
| } |
| } else { |
| if (mViewBody.isShown()) { |
| mWnn.setCandidatesViewShown(false); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Set the view layout |
| * |
| * @param type View type |
| * @return {@code true} if display is updated; {@code false} if otherwise |
| */ |
| private boolean setViewLayout(int type) { |
| |
| ViewGroup.LayoutParams params; |
| int line = (mPortrait) ? mPortraitNumberOfLine : mLandscapeNumberOfLine; |
| |
| if ((mViewType == CandidatesViewManager.VIEW_TYPE_FULL) |
| && (type == CandidatesViewManager.VIEW_TYPE_NORMAL)) { |
| clearFocusCandidate(); |
| } |
| |
| mViewType = type; |
| |
| switch (type) { |
| case CandidatesViewManager.VIEW_TYPE_CLOSE: |
| params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, |
| getCandidateMinimumHeight() * line); |
| mViewBodyScroll.setLayoutParams(params); |
| mViewCandidateListTab.setVisibility(View.GONE); |
| mViewCandidateBase.setMinimumHeight(-1); |
| mHandler.removeMessages(MSG_SET_CANDIDATES); |
| return false; |
| |
| case CandidatesViewManager.VIEW_TYPE_NORMAL: |
| params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, |
| getCandidateMinimumHeight() * line); |
| mViewBodyScroll.setLayoutParams(params); |
| mViewBodyScroll.scrollTo(0, 0); |
| mViewCandidateListTab.setVisibility(View.GONE); |
| mViewCandidateList1st.setVisibility(View.VISIBLE); |
| mViewCandidateList2nd.setVisibility(View.GONE); |
| mViewCandidateBase.setMinimumHeight(-1); |
| return false; |
| |
| case CandidatesViewManager.VIEW_TYPE_FULL: |
| default: |
| params = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.FILL_PARENT, |
| getCandidateViewHeight()); |
| mViewBodyScroll.setLayoutParams(params); |
| if (mIsSymbolMode) { |
| updateSymbolType(); |
| mViewCandidateListTab.setVisibility(View.VISIBLE); |
| } else { |
| mViewCandidateListTab.setVisibility(View.GONE); |
| } |
| mViewCandidateList2nd.setVisibility(View.VISIBLE); |
| mViewCandidateBase.setMinimumHeight(-1); |
| return true; |
| } |
| } |
| |
| /** @see CandidatesViewManager#getViewType */ |
| public int getViewType() { |
| return mViewType; |
| } |
| |
| /** @see CandidatesViewManager#displayCandidates */ |
| public void displayCandidates(WnnEngine converter) { |
| |
| mHandler.removeMessages(MSG_SET_CANDIDATES); |
| |
| if (mIsSymbolSelected) { |
| mIsSymbolSelected = false; |
| if (mSymbolMode == OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI) { |
| return; |
| } |
| |
| int prevLineCount = mLineCount; |
| int prevWordCount1st = mWordCount1st; |
| clearNormalViewCandidate(); |
| mWordCount1st = 0; |
| mLineCount = 1; |
| mLineLength = 0; |
| mNormalViewWordCountOfLine = 0; |
| mWnnWordArray1st.clear(); |
| mTextViewArray1st.clear(); |
| if (((prevWordCount1st == 0) && (mWordCount1st == 1)) || |
| (prevLineCount < mLineCount)) { |
| mViewBodyScroll.scrollTo(0, mViewBodyScroll.getScrollY() + getCandidateMinimumHeight()); |
| } |
| if (isFocusCandidate() && mHasFocusedArray1st) { |
| mCurrentFocusIndex = 0; |
| Message m = mHandler.obtainMessage(MSG_MOVE_FOCUS, 0, 0); |
| mHandler.sendMessage(m); |
| } |
| return; |
| } |
| |
| mCanReadMore = false; |
| mDisplayEndOffset = 0; |
| mIsFullView = false; |
| mFullViewWordCount = 0; |
| mFullViewOccupyCount = 0; |
| mFullViewPrevLineTopId = 0; |
| mFullViewPrevView = null; |
| mCreateCandidateDone = false; |
| mNormalViewWordCountOfLine = 0; |
| |
| clearCandidates(); |
| mConverter = converter; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| |
| mViewCandidateTemplate.setVisibility(View.VISIBLE); |
| mViewCandidateTemplate.setBackgroundResource(R.drawable.cand_back); |
| |
| displayCandidates(converter, true, getMaxLine()); |
| |
| if (mIsSymbolMode) { |
| mIsFullView = true; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_FULL)); |
| } |
| } |
| |
| /** @see CandidatesViewManager#getMaxLine */ |
| private int getMaxLine() { |
| int maxLine = (mPortrait) ? mPortraitNumberOfLine : mLandscapeNumberOfLine; |
| return maxLine; |
| } |
| |
| /** |
| * Get categories text. |
| * @param String Source string replacement |
| * @return String Categories text |
| */ |
| private String getCategoriesText(String categoriesString) { |
| String ret = null; |
| |
| Resources r = mWnn.getResources(); |
| if(categoriesString.equals(r.getString(R.string.half_symbol_categories_txt))) { |
| ret = r.getString(R.string.half_symbol_txt); |
| } else if (categoriesString.equals(r.getString(R.string.full_symbol_categories_txt))) { |
| ret = r.getString(R.string.full_symbol_txt); |
| } else { |
| ret = new String(""); |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * Display the candidates. |
| * |
| * @param converter {@link WnnEngine} which holds candidates. |
| * @param dispFirst Whether it is the first time displaying the candidates |
| * @param maxLine The maximum number of displaying lines |
| */ |
| private void displayCandidates(WnnEngine converter, boolean dispFirst, int maxLine) { |
| if (converter == null) { |
| return; |
| } |
| |
| /* Concatenate the candidates already got and the last one in dispFirst mode */ |
| int displayLimit = mDisplayLimit; |
| |
| boolean isDelay = false; |
| boolean isBreak = false; |
| |
| if (converter instanceof SymbolList) { |
| if (!dispFirst) { |
| if (maxLine == -1) { |
| isDelay = true; |
| maxLine = mLineCount + SET_CANDIDATE_FIRST_LINE_COUNT; |
| |
| mHandler.sendEmptyMessageDelayed(MSG_SET_CANDIDATES, SET_CANDIDATE_DELAY); |
| |
| } else if (maxLine == SET_CANDIDATE_DELAY_LINE_COUNT) { |
| isDelay = true; |
| maxLine = mLineCount + SET_CANDIDATE_DELAY_LINE_COUNT; |
| |
| mHandler.sendEmptyMessageDelayed(MSG_SET_CANDIDATES, SET_CANDIDATE_DELAY); |
| } |
| } |
| if (mSymbolMode != OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI) { |
| displayLimit = -1; |
| } |
| } |
| |
| /* Get candidates */ |
| WnnWord result = null; |
| String prevCandidate = null; |
| while ((displayLimit == -1 || getWordCount() < displayLimit)) { |
| for (int i = 0; i < DISPLAY_LINE_MAX_COUNT; i++) { |
| result = converter.getNextCandidate(); |
| if (result == null) { |
| break; |
| } |
| |
| if (converter instanceof SymbolList) { |
| break; |
| } |
| |
| if ((prevCandidate == null) || !prevCandidate.equals(result.candidate)) { |
| break; |
| } |
| } |
| |
| if (result == null) { |
| break; |
| } else { |
| prevCandidate = result.candidate; |
| } |
| |
| if (converter instanceof SymbolList) { |
| if (isCategory(result)) { |
| if (getWordCount() != 0) { |
| createNextLine(false); |
| } |
| result.candidate = getCategoriesText(result.candidate); |
| setCandidate(true, result); |
| createNextLine(true); |
| continue; |
| } |
| } |
| |
| setCandidate(false, result); |
| |
| if ((dispFirst || isDelay) && (maxLine < mLineCount)) { |
| mCanReadMore = true; |
| isBreak = true; |
| break; |
| } |
| } |
| |
| if (!isBreak && !mCreateCandidateDone) { |
| /* align left if necessary */ |
| createNextLine(false); |
| mCreateCandidateDone = true; |
| mHandler.removeMessages(MSG_SET_CANDIDATES); |
| mHandler.sendMessage(mHandler.obtainMessage(MSG_SELECT_CANDIDATES)); |
| } |
| |
| if (getWordCount() < 1) { /* no candidates */ |
| if (mAutoHideMode) { |
| mWnn.setCandidatesViewShown(false); |
| return; |
| } else { |
| mCanReadMore = false; |
| mIsFullView = false; |
| setViewLayout(CandidatesViewManager.VIEW_TYPE_NORMAL); |
| } |
| } |
| |
| setReadMore(); |
| |
| if (!(mViewBody.isShown())) { |
| mWnn.setCandidatesViewShown(true); |
| } |
| return; |
| } |
| |
| /** |
| * Add a candidate into the list. |
| * @param isCategory {@code true}:caption of category, {@code false}:normal word |
| * @param word A candidate word |
| */ |
| private void setCandidate(boolean isCategory, WnnWord word) { |
| int textLength = measureText(word.candidate, 0, word.candidate.length()); |
| TextView template = mViewCandidateTemplate; |
| textLength += template.getPaddingLeft() + template.getPaddingRight(); |
| int maxWidth = mViewWidth; |
| boolean isEmojiSymbol = false; |
| if (mIsSymbolMode && (word.candidate.length() < 3)) { |
| isEmojiSymbol = true; |
| } |
| TextView textView; |
| |
| boolean is2nd = isFirstListOver(mIsFullView, mLineCount, word); |
| if (is2nd) { |
| /* Full view */ |
| int viewDivison = getCandidateViewDivison(); |
| int indentWidth = mViewWidth / viewDivison; |
| int occupyCount = Math.min((textLength + indentWidth + getCandidateSpaceWidth(isEmojiSymbol)) / indentWidth, viewDivison); |
| if (isCategory) { |
| occupyCount = viewDivison; |
| } |
| |
| if (viewDivison < (mFullViewOccupyCount + occupyCount)) { |
| if (viewDivison != mFullViewOccupyCount) { |
| mFullViewPrevParams.width += (viewDivison - mFullViewOccupyCount) * indentWidth; |
| if (mFullViewPrevView != null) { |
| mViewCandidateList2nd.updateViewLayout(mFullViewPrevView, mFullViewPrevParams); |
| } |
| } |
| mFullViewOccupyCount = 0; |
| if (mFullViewPrevView != null) { |
| mFullViewPrevLineTopId = mFullViewPrevView.getId(); |
| } |
| mLineCount++; |
| if (isCategory) { |
| mLineY += mCandidateCategoryMinimumHeight; |
| } else { |
| mLineY += getCandidateMinimumHeight(); |
| } |
| } |
| if (mFullViewWordCount == 0) { |
| mLineY = 0; |
| } |
| |
| ViewGroup layout = mViewCandidateList2nd; |
| |
| int width = indentWidth * occupyCount; |
| int height = getCandidateMinimumHeight(); |
| if (isCategory) { |
| height = mCandidateCategoryMinimumHeight; |
| } |
| |
| ViewGroup.LayoutParams params = buildLayoutParams(mViewCandidateList2nd, width, height); |
| |
| textView = (TextView) layout.getChildAt(mFullViewWordCount); |
| if (textView == null) { |
| textView = createCandidateView(); |
| textView.setLayoutParams(params); |
| |
| mViewCandidateList2nd.addView(textView); |
| } else { |
| mViewCandidateList2nd.updateViewLayout(textView, params); |
| } |
| |
| mFullViewOccupyCount += occupyCount; |
| mFullViewWordCount++; |
| mFullViewPrevView = textView; |
| mFullViewPrevParams = params; |
| |
| } else { |
| int viewDivison = getCandidateViewDivison(); |
| int indentWidth = mViewWidth / viewDivison; |
| textLength = Math.max(textLength, indentWidth); |
| |
| /* Normal view */ |
| int nextEnd = mLineLength + textLength; |
| nextEnd += getCandidateSpaceWidth(isEmojiSymbol); |
| |
| if (mLineCount == 1 && !mIsSymbolMode) { |
| maxWidth -= getCandidateMinimumWidth(); |
| } |
| |
| if ((maxWidth < nextEnd) && (getWordCount() != 0)) { |
| |
| createNextLineFor1st(); |
| if (getMaxLine() < mLineCount) { |
| mLineLength = 0; |
| /* Call this method again to add the candidate in the full view */ |
| if (!mIsSymbolSelected) { |
| setCandidate(isCategory, word); |
| } |
| return; |
| } |
| |
| mLineLength = textLength; |
| mLineLength += getCandidateSpaceWidth(isEmojiSymbol); |
| } else { |
| mLineLength = nextEnd; |
| } |
| |
| LinearLayout lineView = (LinearLayout) mViewCandidateList1st.getChildAt(mLineCount - 1); |
| textView = (TextView) lineView.getChildAt(mNormalViewWordCountOfLine); |
| |
| if (isCategory) { |
| if (mLineCount == 1) { |
| mViewCandidateTemplate.setBackgroundDrawable(null); |
| } |
| mLineLength += mCandidateLeftAlignThreshold; |
| } else { |
| int CompareLength = textLength; |
| CompareLength += getCandidateSpaceWidth(isEmojiSymbol); |
| } |
| |
| mNormalViewWordCountOfLine++; |
| } |
| |
| textView.setText(word.candidate); |
| if (is2nd) { |
| textView.setId(mWordCount2nd); |
| } else { |
| textView.setId(mWordCount1st); |
| } |
| textView.setVisibility(View.VISIBLE); |
| textView.setPressed(false); |
| textView.setFocusable(false); |
| |
| if (isCategory) { |
| textView.setText(" " + word.candidate); |
| |
| textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, mCandCategoryTextSize); |
| textView.setBackgroundDrawable(null); |
| textView.setGravity(Gravity.CENTER_VERTICAL); |
| textView.setMinHeight(mCandidateCategoryMinimumHeight); |
| textView.setHeight(mCandidateCategoryMinimumHeight); |
| |
| textView.setOnClickListener(null); |
| textView.setOnLongClickListener(null); |
| textView.setTextColor(mTextColor); |
| } else { |
| textView.setTextSize(TypedValue.COMPLEX_UNIT_PX, mCandNormalTextSize); |
| textView.setGravity(Gravity.CENTER); |
| textView.setMinHeight(getCandidateMinimumHeight()); |
| textView.setHeight(getCandidateMinimumHeight()); |
| |
| if (is2nd) { |
| textView.setOnClickListener(mCandidateOnClick2nd); |
| textView.setOnLongClickListener(mCandidateOnLongClick2nd); |
| } else { |
| textView.setOnClickListener(mCandidateOnClick1st); |
| textView.setOnLongClickListener(mCandidateOnLongClick1st); |
| } |
| |
| textView.setBackgroundResource(R.drawable.cand_back); |
| |
| textView.setTextColor(mTextColor); |
| } |
| |
| if (maxWidth < textLength) { |
| textView.setEllipsize(TextUtils.TruncateAt.END); |
| } else { |
| textView.setEllipsize(null); |
| } |
| |
| ImageSpan span = null; |
| if (word.candidate.equals(" ")) { |
| span = new ImageSpan(mWnn, R.drawable.word_half_space, |
| DynamicDrawableSpan.ALIGN_BASELINE); |
| } else if (word.candidate.equals("\u3000" /* full-width space */)) { |
| span = new ImageSpan(mWnn, R.drawable.word_full_space, |
| DynamicDrawableSpan.ALIGN_BASELINE); |
| } |
| |
| if (span != null) { |
| SpannableString spannable = new SpannableString(" "); |
| spannable.setSpan(span, 1, 2, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE); |
| textView.setText(spannable); |
| } |
| textView.setPadding(0, 0, 0, 0); |
| |
| if (is2nd) { |
| mWnnWordArray2nd.add(mWordCount2nd, word); |
| mWordCount2nd++; |
| mTextViewArray2nd.add(textView); |
| } else { |
| mWnnWordArray1st.add(mWordCount1st, word); |
| mWordCount1st++; |
| mTextViewArray1st.add(textView); |
| } |
| } |
| |
| /** |
| * Create AbsoluteLayout.LayoutParams |
| * @param layout AbsoluteLayout |
| * @param width The width of the display |
| * @param height The height of the display |
| * @return Layout parameter |
| */ |
| private ViewGroup.LayoutParams buildLayoutParams(AbsoluteLayout layout, int width, int height) { |
| |
| int viewDivison = getCandidateViewDivison(); |
| int indentWidth = mViewWidth / viewDivison; |
| int x = indentWidth * mFullViewOccupyCount; |
| int y = mLineY; |
| ViewGroup.LayoutParams params |
| = new AbsoluteLayout.LayoutParams(width, height, x, y); |
| |
| return params; |
| } |
| |
| /** |
| * Create a view for a candidate. |
| * @return the view |
| */ |
| private TextView createCandidateView() { |
| TextView text = new CandidateTextView(mViewBodyScroll.getContext()); |
| text.setTextSize(TypedValue.COMPLEX_UNIT_PX, mCandNormalTextSize); |
| text.setBackgroundResource(R.drawable.cand_back); |
| text.setCompoundDrawablePadding(0); |
| text.setGravity(Gravity.CENTER); |
| text.setSingleLine(); |
| text.setPadding(0, 0, 0, 0); |
| text.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT, |
| 1.0f)); |
| text.setMinHeight(getCandidateMinimumHeight()); |
| text.setMinimumWidth(getCandidateMinimumWidth()); |
| text.setSoundEffectsEnabled(false); |
| return text; |
| } |
| |
| /** |
| * Display {@code mReadMoreText} if there are more candidates. |
| */ |
| private void setReadMore() { |
| if (mIsSymbolMode) { |
| mReadMoreButton.setVisibility(View.GONE); |
| mViewCandidateTemplate.setVisibility(View.GONE); |
| return; |
| } |
| |
| int resid = 0; |
| |
| if (mIsFullView) { |
| mReadMoreButton.setVisibility(View.VISIBLE); |
| resid = R.drawable.cand_up; |
| } else { |
| if (mCanReadMore) { |
| mReadMoreButton.setVisibility(View.VISIBLE); |
| resid = R.drawable.cand_down; |
| } else { |
| mReadMoreButton.setVisibility(View.GONE); |
| mViewCandidateTemplate.setVisibility(View.GONE); |
| } |
| } |
| |
| if (resid != 0) { |
| mReadMoreButton.setImageResource(resid); |
| } |
| } |
| |
| /** |
| * Clear the list of the normal candidate view. |
| */ |
| private void clearNormalViewCandidate() { |
| LinearLayout candidateList = mViewCandidateList1st; |
| int lineNum = candidateList.getChildCount(); |
| for (int i = 0; i < lineNum; i++) { |
| |
| LinearLayout lineView = (LinearLayout)candidateList.getChildAt(i); |
| int size = lineView.getChildCount(); |
| for (int j = 0; j < size; j++) { |
| View v = lineView.getChildAt(j); |
| v.setVisibility(View.GONE); |
| } |
| } |
| } |
| |
| /** @see CandidatesViewManager#clearCandidates */ |
| public void clearCandidates() { |
| closeDialog(); |
| clearFocusCandidate(); |
| clearNormalViewCandidate(); |
| |
| ViewGroup layout = mViewCandidateList2nd; |
| int size = layout.getChildCount(); |
| for (int i = 0; i < size; i++) { |
| View v = layout.getChildAt(i); |
| v.setVisibility(View.GONE); |
| } |
| |
| mLineCount = 1; |
| mWordCount1st = 0; |
| mWordCount2nd = 0; |
| mWnnWordArray1st.clear(); |
| mWnnWordArray2nd.clear(); |
| mTextViewArray1st.clear(); |
| mTextViewArray2nd.clear(); |
| mLineLength = 0; |
| |
| mLineY = 0; |
| |
| mIsFullView = false; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| if (mAutoHideMode) { |
| setViewLayout(CandidatesViewManager.VIEW_TYPE_CLOSE); |
| } |
| |
| if (mAutoHideMode && mViewBody.isShown()) { |
| mWnn.setCandidatesViewShown(false); |
| } |
| mCanReadMore = false; |
| setReadMore(); |
| } |
| |
| /** @see CandidatesViewManager#setPreferences */ |
| public void setPreferences(SharedPreferences pref) { |
| try { |
| if (pref.getBoolean("key_vibration", false)) { |
| mVibrator = (Vibrator)mWnn.getSystemService(Context.VIBRATOR_SERVICE); |
| } else { |
| mVibrator = null; |
| } |
| if (pref.getBoolean("key_sound", false)) { |
| mSound = (AudioManager)mWnn.getSystemService(Context.AUDIO_SERVICE); |
| } else { |
| mSound = null; |
| } |
| setNumeberOfDisplayLines(); |
| } catch (Exception ex) { |
| Log.e("OpenWnn", "NO VIBRATOR"); |
| } |
| } |
| |
| /** |
| * Set normal mode. |
| */ |
| public void setNormalMode() { |
| setReadMore(); |
| mIsFullView = false; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| } |
| |
| /** |
| * Set full mode. |
| */ |
| public void setFullMode() { |
| mIsFullView = true; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_FULL)); |
| } |
| |
| /** |
| * Set symbol mode. |
| */ |
| public void setSymbolMode(boolean enable, int mode) { |
| if (mIsSymbolMode && !enable) { |
| setViewType(CandidatesViewManager.VIEW_TYPE_CLOSE); |
| } |
| mSymbolMode = mode; |
| mIsSymbolMode = enable; |
| } |
| |
| /** |
| * Set scroll up. |
| */ |
| public void setScrollUp() { |
| if (!mViewBodyScroll.pageScroll(ScrollView.FOCUS_UP)) { |
| mViewBodyScroll.scrollTo(0, mViewBodyScroll.getChildAt(0).getHeight()); |
| } |
| } |
| |
| /** |
| * Set scroll down. |
| */ |
| public void setScrollDown() { |
| if (!mViewBodyScroll.pageScroll(ScrollView.FOCUS_DOWN)) { |
| mViewBodyScroll.scrollTo(0, 0); |
| } |
| } |
| |
| /** |
| * Set scroll full up. |
| */ |
| public void setScrollFullUp() { |
| if (!mViewBodyScroll.fullScroll(ScrollView.FOCUS_UP)) { |
| mViewBodyScroll.scrollTo(0, mViewBodyScroll.getChildAt(0).getHeight()); |
| } |
| } |
| |
| /** |
| * Set scroll full down. |
| */ |
| public void setScrollFullDown() { |
| if (!mViewBodyScroll.fullScroll(ScrollView.FOCUS_DOWN)) { |
| mViewBodyScroll.scrollTo(0, 0); |
| } |
| } |
| |
| /** |
| * Process {@link OpenWnnEvent#CANDIDATE_VIEW_TOUCH} event. |
| * |
| * @return {@code true} if event is processed; {@code false} if otherwise |
| */ |
| public boolean onTouchSync() { |
| return mGestureDetector.onTouchEvent(mMotionEvent); |
| } |
| |
| /** |
| * Select a candidate. |
| * <br> |
| * This method notices the selected word to {@link OpenWnn}. |
| * |
| * @param word The selected word |
| */ |
| private void selectCandidate(WnnWord word) { |
| if (!mIsSymbolMode) { |
| mIsFullView = false; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| } |
| mIsSymbolSelected = mIsSymbolMode; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.SELECT_CANDIDATE, word)); |
| } |
| |
| private void playSoundAndVibration() { |
| if (mVibrator != null) { |
| try { |
| mVibrator.vibrate(5); |
| } catch (Exception ex) { |
| Log.e("OpenWnn", "TextCandidatesViewManager::selectCandidate Vibrator " + ex.toString()); |
| } |
| } |
| if (mSound != null) { |
| try { |
| mSound.playSoundEffect(AudioManager.FX_KEYPRESS_STANDARD, -1); |
| } catch (Exception ex) { |
| Log.e("OpenWnn", "TextCandidatesViewManager::selectCandidate Sound " + ex.toString()); |
| } |
| } |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onDown */ |
| public boolean onDown(MotionEvent arg0) { |
| return false; |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onFling */ |
| public boolean onFling(MotionEvent arg0, MotionEvent arg1, float arg2, float arg3) { |
| boolean consumed = false; |
| if (arg1 != null && arg0 != null && arg1.getY() < arg0.getY()) { |
| if ((mViewType == CandidatesViewManager.VIEW_TYPE_NORMAL) && mCanReadMore) { |
| if (mVibrator != null) { |
| try { |
| mVibrator.vibrate(5); |
| } catch (Exception ex) { |
| Log.e("iwnn", "TextCandidatesViewManager::onFling Vibrator " + ex.toString()); |
| } |
| } |
| mIsFullView = true; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_FULL)); |
| consumed = true; |
| } |
| } else { |
| if (mViewBodyScroll.getScrollY() == 0) { |
| if (mVibrator != null) { |
| try { |
| mVibrator.vibrate(5); |
| } catch (Exception ex) { |
| Log.e("iwnn", "TextCandidatesViewManager::onFling Sound " + ex.toString()); |
| } |
| } |
| mIsFullView = false; |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.LIST_CANDIDATES_NORMAL)); |
| consumed = true; |
| } |
| } |
| |
| return consumed; |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onLongPress */ |
| public void onLongPress(MotionEvent arg0) { |
| return; |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onScroll */ |
| public boolean onScroll(MotionEvent arg0, MotionEvent arg1, float arg2, float arg3) { |
| return false; |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onShowPress */ |
| public void onShowPress(MotionEvent arg0) { |
| } |
| |
| /** @see android.view.GestureDetector.OnGestureListener#onSingleTapUp */ |
| public boolean onSingleTapUp(MotionEvent arg0) { |
| return false; |
| } |
| |
| /** |
| * Retrieve the width of string to draw. |
| * |
| * @param text The string |
| * @param start The start position (specified by the number of character) |
| * @param end The end position (specified by the number of character) |
| * @return The width of string to draw |
| */ |
| public int measureText(CharSequence text, int start, int end) { |
| if (end - start < 3) { |
| return getCandidateMinimumWidth(); |
| } |
| |
| TextPaint paint = mViewCandidateTemplate.getPaint(); |
| return (int)paint.measureText(text, start, end); |
| } |
| |
| /** |
| * Create a layout for the next line. |
| */ |
| private void createNextLine(boolean isCategory) { |
| if (isFirstListOver(mIsFullView, mLineCount, null)) { |
| /* Full view */ |
| mFullViewOccupyCount = 0; |
| if (mFullViewPrevView != null) { |
| mFullViewPrevLineTopId = mFullViewPrevView.getId(); |
| } |
| if (isCategory) { |
| mLineY += mCandidateCategoryMinimumHeight; |
| } else { |
| mLineY += getCandidateMinimumHeight(); |
| } |
| mLineCount++; |
| } else { |
| createNextLineFor1st(); |
| } |
| } |
| |
| /** |
| * Create a layout for the next line. |
| */ |
| private void createNextLineFor1st() { |
| LinearLayout lineView = (LinearLayout) mViewCandidateList1st.getChildAt(mLineCount - 1); |
| float weight = 0; |
| if (mLineLength < mCandidateLeftAlignThreshold) { |
| if (mLineCount == 1) { |
| mViewCandidateTemplate.setVisibility(View.GONE); |
| } |
| } else { |
| weight = 1.0f; |
| } |
| |
| LinearLayout.LayoutParams params |
| = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, |
| ViewGroup.LayoutParams.WRAP_CONTENT, |
| weight); |
| |
| int child = lineView.getChildCount(); |
| for (int i = 0; i < child; i++) { |
| View view = lineView.getChildAt(i); |
| |
| if (view != mViewCandidateTemplate) { |
| view.setLayoutParams(params); |
| view.setPadding(0, 0, 0, 0); |
| } |
| } |
| |
| mLineLength = 0; |
| mNormalViewWordCountOfLine = 0; |
| mLineCount++; |
| } |
| |
| /** |
| * Judge if it's a category. |
| * |
| * @return {@code true} if category |
| */ |
| boolean isCategory(WnnWord word) { |
| int length = word.candidate.length(); |
| return ((length > 3) && (word.candidate.charAt(0) == '[')); |
| } |
| |
| /** |
| * Get a minimum width of a candidate view. |
| * |
| * @return the minimum width of a candidate view. |
| */ |
| private int getCandidateMinimumWidth() { |
| return mCandidateMinimumWidth; |
| } |
| |
| /** |
| * @return the minimum height of a candidate view. |
| */ |
| private int getCandidateMinimumHeight() { |
| return mCandidateMinimumHeight; |
| } |
| |
| /** |
| * Get a height of a candidate view. |
| * |
| * @return the height of a candidate view. |
| */ |
| private int getCandidateViewHeight() { |
| if (OpenWnn.isXLarge()) { |
| return mKeyboardHeight + mCandidateOneLineMinimumHeight - mSymbolKeyboardHeight |
| - mSymbolKeyboardTabHeight; |
| } else { |
| int numberOfLine = (mPortrait) ? mPortraitNumberOfLine : mLandscapeNumberOfLine; |
| Resources resource = mWnn.getResources(); |
| Drawable keyboardBackground = resource.getDrawable(R.drawable.keyboard_background); |
| Rect keyboardPadding = new Rect(0 ,0 ,0 ,0); |
| keyboardBackground.getPadding(keyboardPadding); |
| int keyboardTotalPadding = keyboardPadding.top + keyboardPadding.bottom; |
| if (mIsSymbolMode) { |
| return mKeyboardHeight + numberOfLine * getCandidateMinimumHeight() |
| - mSymbolKeyboardHeight - mSymbolKeyboardTabHeight; |
| } else if (!mHardKeyboardHidden) { |
| return mKeyboardHeight + numberOfLine * getCandidateMinimumHeight() |
| - mSymbolKeyboardHeight; |
| } else { |
| return mKeyboardHeight + keyboardTotalPadding |
| + numberOfLine * getCandidateMinimumHeight(); |
| } |
| } |
| } |
| |
| /** |
| * Update symbol type. |
| */ |
| private void updateSymbolType() { |
| switch (mSymbolMode) { |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL: |
| updateTabStatus(mViewTabSymbol, true, true); |
| updateTabStatus(mViewTabEmoticon, mEnableEmoticon, false); |
| break; |
| |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI: |
| updateTabStatus(mViewTabSymbol, true, false); |
| updateTabStatus(mViewTabEmoticon, mEnableEmoticon, true); |
| break; |
| |
| default: |
| updateTabStatus(mViewTabSymbol, true, false); |
| updateTabStatus(mViewTabEmoticon, mEnableEmoticon, false); |
| break; |
| } |
| } |
| |
| /** |
| * Update tab status. |
| * |
| * @param tab The tab view. |
| * @param enabled The tab is enabled. |
| * @param selected The tab is selected. |
| */ |
| private void updateTabStatus(TextView tab, boolean enabled, boolean selected) { |
| tab.setVisibility(View.VISIBLE); |
| tab.setEnabled(enabled); |
| int backgroundId = 0; |
| int colorId = 0; |
| if (enabled) { |
| if (selected) { |
| backgroundId = R.drawable.cand_tab; |
| colorId = R.color.tab_textcolor_select; |
| } else { |
| backgroundId = R.drawable.cand_tab_noselect; |
| colorId = R.color.tab_textcolor_no_select; |
| } |
| } else { |
| backgroundId = R.drawable.cand_tab_noselect; |
| colorId = R.color.tab_textcolor_disable; |
| } |
| tab.setBackgroundResource(backgroundId); |
| tab.setTextColor(mWnn.getResources().getColor(colorId)); |
| } |
| |
| /** |
| * Get candidate number of division. |
| * @return Number of division |
| */ |
| private int getCandidateViewDivison() { |
| int viewDivison; |
| |
| if (mIsSymbolMode) { |
| int mode = mSymbolMode; |
| switch (mode) { |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL: |
| viewDivison = (mPortrait) ? FULL_VIEW_SYMBOL_DIV_PORT : FULL_VIEW_SYMBOL_DIV_LAND; |
| break; |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI: |
| default: |
| viewDivison = FULL_VIEW_DIV; |
| break; |
| } |
| } else { |
| viewDivison = FULL_VIEW_DIV; |
| } |
| return viewDivison; |
| } |
| |
| /** |
| * @return Word count |
| */ |
| private int getWordCount() { |
| return mWordCount1st + mWordCount2nd; |
| } |
| |
| /** |
| * @return Add second |
| */ |
| private boolean isFirstListOver(boolean isFullView, int lineCount, WnnWord word) { |
| |
| if (mIsSymbolMode) { |
| switch (mSymbolMode) { |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL_KAO_MOJI: |
| return true; |
| case OpenWnnJAJP.ENGINE_MODE_SYMBOL: |
| return true; |
| default: |
| return (isFullView || getMaxLine() < lineCount); |
| } |
| } else { |
| return (isFullView || getMaxLine() < lineCount); |
| } |
| } |
| |
| /** |
| * @return Candidate space width |
| */ |
| private int getCandidateSpaceWidth(boolean isEmojiSymbol) { |
| Resources r = mWnn.getResources(); |
| if (mPortrait) { |
| if (isEmojiSymbol) { |
| return 0; |
| } else { |
| return r.getDimensionPixelSize(R.dimen.cand_space_width); |
| } |
| } else { |
| if (isEmojiSymbol) { |
| return r.getDimensionPixelSize(R.dimen.cand_space_width_emoji_symbol); |
| } else { |
| return r.getDimensionPixelSize(R.dimen.cand_space_width); |
| } |
| } |
| } |
| |
| /** |
| * KeyEvent action for the candidate view. |
| * |
| * @param key Key event |
| */ |
| public void processMoveKeyEvent(int key) { |
| if (!mViewBody.isShown()) { |
| return; |
| } |
| |
| switch (key) { |
| case KeyEvent.KEYCODE_DPAD_UP: |
| moveFocus(-1, true); |
| break; |
| |
| case KeyEvent.KEYCODE_DPAD_DOWN: |
| moveFocus(1, true); |
| break; |
| |
| case KeyEvent.KEYCODE_DPAD_LEFT: |
| moveFocus(-1, false); |
| break; |
| |
| case KeyEvent.KEYCODE_DPAD_RIGHT: |
| moveFocus(1, false); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| /** |
| * Get a flag candidate is focused now. |
| * |
| * @return the Candidate is focused of a flag. |
| */ |
| public boolean isFocusCandidate(){ |
| if (mCurrentFocusIndex != FOCUS_NONE) { |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Give focus to View of candidate. |
| */ |
| public void setViewStatusOfFocusedCandidate(){ |
| View view = mFocusedView; |
| if (view != null) { |
| view.setBackgroundDrawable(mFocusedViewBackground); |
| view.setPadding(0, 0, 0, 0); |
| } |
| |
| TextView v = getFocusedView(); |
| mFocusedView = v; |
| if (v != null) { |
| mFocusedViewBackground = v.getBackground(); |
| v.setBackgroundResource(R.drawable.cand_back_focuse); |
| v.setPadding(0, 0, 0, 0); |
| |
| int viewBodyTop = getViewTopOnScreen(mViewBodyScroll); |
| int viewBodyBottom = viewBodyTop + mViewBodyScroll.getHeight(); |
| int focusedViewTop = getViewTopOnScreen(v); |
| int focusedViewBottom = focusedViewTop + v.getHeight(); |
| |
| if (focusedViewBottom > viewBodyBottom) { |
| mViewBodyScroll.scrollBy(0, (focusedViewBottom - viewBodyBottom)); |
| } else if (focusedViewTop < viewBodyTop) { |
| mViewBodyScroll.scrollBy(0, (focusedViewTop - viewBodyTop)); |
| } |
| } |
| } |
| |
| /** |
| * Clear focus to selected candidate. |
| */ |
| public void clearFocusCandidate(){ |
| View view = mFocusedView; |
| if (view != null) { |
| view.setBackgroundDrawable(mFocusedViewBackground); |
| view.setPadding(0, 0, 0, 0); |
| mFocusedView = null; |
| } |
| |
| mFocusAxisX = 0; |
| mHasFocusedArray1st = true; |
| mCurrentFocusIndex = FOCUS_NONE; |
| mHandler.removeMessages(MSG_MOVE_FOCUS); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.FOCUS_CANDIDATE_END)); |
| } |
| |
| /** |
| * @see CandidatesViewManager#selectFocusCandidate |
| */ |
| public void selectFocusCandidate(){ |
| if (mCurrentFocusIndex != FOCUS_NONE) { |
| WnnWord word = getFocusedWnnWord(); |
| |
| if (mHandler.hasMessages(MSG_SET_CANDIDATES)) { |
| mWnnWordSelectedList.add(word); |
| } else { |
| selectCandidate(word); |
| } |
| } |
| } |
| |
| /** @see CandidatesViewManager#getFocusedWnnWord */ |
| public WnnWord getFocusedWnnWord() { |
| return getWnnWord(mCurrentFocusIndex); |
| } |
| |
| /** |
| * Get WnnWord. |
| * |
| * @return WnnWord word |
| */ |
| public WnnWord getWnnWord(int index) { |
| WnnWord word = null; |
| if (index < 0) { |
| index = 0; |
| mHandler.removeMessages(MSG_MOVE_FOCUS); |
| Log.i("iwnn", "TextCandidatesViewManager::getWnnWord index < 0 "); |
| } else { |
| int size = mHasFocusedArray1st ? mWnnWordArray1st.size() : mWnnWordArray2nd.size(); |
| if (index >= size) { |
| index = size - 1; |
| mHandler.removeMessages(MSG_MOVE_FOCUS); |
| Log.i("iwnn", "TextCandidatesViewManager::getWnnWord index > candidate max "); |
| } |
| } |
| |
| if (mHasFocusedArray1st) { |
| word = mWnnWordArray1st.get(index); |
| } else { |
| word = mWnnWordArray2nd.get(index); |
| } |
| return word; |
| } |
| |
| /** |
| * Set display candidate line from SharedPreferences. |
| */ |
| private void setNumeberOfDisplayLines(){ |
| SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(mWnn); |
| mPortraitNumberOfLine = Integer.parseInt(pref.getString("setting_portrait", "2")); |
| mLandscapeNumberOfLine = Integer.parseInt(pref.getString("setting_landscape", "1")); |
| } |
| |
| /** |
| * Set emoticon enabled. |
| */ |
| public void setEnableEmoticon(boolean enableEmoticon) { |
| mEnableEmoticon = enableEmoticon; |
| } |
| |
| /** |
| * Get View of focus candidate. |
| */ |
| public TextView getFocusedView() { |
| if (mCurrentFocusIndex == FOCUS_NONE) { |
| return null; |
| } |
| TextView t; |
| if (mHasFocusedArray1st) { |
| t = mTextViewArray1st.get(mCurrentFocusIndex); |
| } else { |
| t = mTextViewArray2nd.get(mCurrentFocusIndex); |
| } |
| return t; |
| } |
| |
| /** |
| * Move the focus to next candidate. |
| * |
| * @param direction The direction of increment or decrement. |
| * @param updown {@code true} if move is up or down. |
| */ |
| public void moveFocus(int direction, boolean updown) { |
| boolean isStart = (mCurrentFocusIndex == FOCUS_NONE); |
| if (direction == 0) { |
| setViewStatusOfFocusedCandidate(); |
| } |
| |
| int size1st = mTextViewArray1st.size(); |
| if (mHasFocusedArray1st && (size1st == 0)) { |
| mHasFocusedArray1st = false; |
| } |
| ArrayList<TextView> list = mHasFocusedArray1st ? mTextViewArray1st : mTextViewArray2nd; |
| int size = list.size(); |
| int start = (mCurrentFocusIndex == FOCUS_NONE) ? 0 : (mCurrentFocusIndex + direction); |
| |
| int index = -1; |
| boolean hasChangedLine = false; |
| for (int i = start; (0 <= i) && (i < size); i += direction) { |
| TextView view = list.get(i); |
| if (!view.isShown()) { |
| break; |
| } |
| |
| if (mIsSymbolMode && (view.getBackground() == null)) { |
| continue; |
| } |
| |
| if (updown) { |
| int left = view.getLeft(); |
| if ((left <= mFocusAxisX) |
| && (mFocusAxisX < view.getRight())) { |
| index = i; |
| break; |
| } |
| |
| if (left == 0) { |
| hasChangedLine = true; |
| } |
| } else { |
| index = i; |
| break; |
| } |
| } |
| |
| if ((index < 0) && hasChangedLine && !mHasFocusedArray1st && (0 < direction)) { |
| index = mTextViewArray2nd.size() - 1; |
| } |
| |
| if (0 <= index) { |
| mCurrentFocusIndex = index; |
| setViewStatusOfFocusedCandidate(); |
| if (!updown) { |
| mFocusAxisX = getFocusedView().getLeft(); |
| } |
| } else { |
| if (mCanReadMore && (0 < size1st)) { |
| |
| if ((mHasFocusedArray1st && (direction < 0)) |
| || (!mHasFocusedArray1st && (0 < direction))) { |
| updown = false; |
| } |
| |
| mHasFocusedArray1st = !mHasFocusedArray1st; |
| |
| if (!mHasFocusedArray1st && !mIsFullView) { |
| setFullMode(); |
| } |
| } |
| |
| if (size1st == 0) { |
| updown = false; |
| } |
| |
| if (0 < direction) { |
| mCurrentFocusIndex = -1; |
| } else { |
| mCurrentFocusIndex = (mHasFocusedArray1st ? size1st : mTextViewArray2nd.size()); |
| } |
| Message m = mHandler.obtainMessage(MSG_MOVE_FOCUS, direction, updown ? 1 : 0); |
| mHandler.sendMessage(m); |
| } |
| |
| if (isStart) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.FOCUS_CANDIDATE_START)); |
| } |
| } |
| |
| /** |
| * Set hardkeyboard hidden. |
| * |
| * @param hardKeyboardHidden hardkeyaboard hidden. |
| */ |
| public void setHardKeyboardHidden(boolean hardKeyboardHidden) { |
| mHardKeyboardHidden = hardKeyboardHidden; |
| } |
| |
| /** |
| * Get view top position on screen. |
| * |
| * @param view target view. |
| * @return int view top position on screen |
| */ |
| public int getViewTopOnScreen(View view) { |
| int[] location = new int[2]; |
| view.getLocationOnScreen(location); |
| return location[1]; |
| } |
| |
| |
| /** @see CandidatesViewManager#setCandidateMsgRemove */ |
| public void setCandidateMsgRemove() { |
| mHandler.removeMessages(MSG_SET_CANDIDATES); |
| } |
| } |
