Java程序
|
1912行
|
64.62 KB
/*
* 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);
}
}