| /* |
| * 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 android.view.KeyEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputConnection; |
| import android.widget.TextView; |
| import android.content.SharedPreferences; |
| import android.preference.PreferenceManager; |
| import android.content.res.*; |
| import android.os.Vibrator; |
| import android.media.MediaPlayer; |
| import android.content.Context; |
| |
| import android.util.Log; |
| |
| import jp.co.omronsoft.openwnn.Keyboard; |
| import jp.co.omronsoft.openwnn.KeyboardView; |
| import jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener; |
| |
| /** |
| * The default software keyboard class. |
| * |
| * @author Copyright (C) 2009-2011 OMRON SOFTWARE CO., LTD. All Rights Reserved. |
| */ |
| public class DefaultSoftKeyboard implements InputViewManager, KeyboardView.OnKeyboardActionListener { |
| /* |
| *---------------------------------------------------------------------- |
| * key codes for a software keyboard |
| *---------------------------------------------------------------------- |
| */ |
| /** Change the keyboard language */ |
| public static final int KEYCODE_CHANGE_LANG = -500; |
| |
| /* for Japanese 12-key keyboard */ |
| /** Japanese 12-key keyboard [1] */ |
| public static final int KEYCODE_JP12_1 = -201; |
| /** Japanese 12-key keyboard [2] */ |
| public static final int KEYCODE_JP12_2 = -202; |
| /** Japanese 12-key keyboard [3] */ |
| public static final int KEYCODE_JP12_3 = -203; |
| /** Japanese 12-key keyboard [4] */ |
| public static final int KEYCODE_JP12_4 = -204; |
| /** Japanese 12-key keyboard [5] */ |
| public static final int KEYCODE_JP12_5 = -205; |
| /** Japanese 12-key keyboard [6] */ |
| public static final int KEYCODE_JP12_6 = -206; |
| /** Japanese 12-key keyboard [7] */ |
| public static final int KEYCODE_JP12_7 = -207; |
| /** Japanese 12-key keyboard [8] */ |
| public static final int KEYCODE_JP12_8 = -208; |
| /** Japanese 12-key keyboard [9] */ |
| public static final int KEYCODE_JP12_9 = -209; |
| /** Japanese 12-key keyboard [0] */ |
| public static final int KEYCODE_JP12_0 = -210; |
| /** Japanese 12-key keyboard [#] */ |
| public static final int KEYCODE_JP12_SHARP = -211; |
| /** Japanese 12-key keyboard [*] */ |
| public static final int KEYCODE_JP12_ASTER = -213; |
| /** Japanese 12-key keyboard [DEL] */ |
| public static final int KEYCODE_JP12_BACKSPACE = -214; |
| /** Japanese 12-key keyboard [SPACE] */ |
| public static final int KEYCODE_JP12_SPACE = -215; |
| /** Japanese 12-key keyboard [ENTER] */ |
| public static final int KEYCODE_JP12_ENTER = -216; |
| /** Japanese 12-key keyboard [RIGHT ARROW] */ |
| public static final int KEYCODE_JP12_RIGHT = -217; |
| /** Japanese 12-key keyboard [LEFT ARROW] */ |
| public static final int KEYCODE_JP12_LEFT = -218; |
| /** Japanese 12-key keyboard [REVERSE TOGGLE] */ |
| public static final int KEYCODE_JP12_REVERSE = -219; |
| /** Japanese 12-key keyboard [CLOSE] */ |
| public static final int KEYCODE_JP12_CLOSE = -220; |
| /** Japanese 12-key keyboard [KEYBOARD TYPE CHANGE] */ |
| public static final int KEYCODE_JP12_KBD = -221; |
| /** Japanese 12-key keyboard [EMOJI] */ |
| public static final int KEYCODE_JP12_EMOJI = -222; |
| /** Japanese 12-key keyboard [FULL-WIDTH HIRAGANA MODE] */ |
| public static final int KEYCODE_JP12_ZEN_HIRA = -223; |
| /** Japanese 12-key keyboard [FULL-WIDTH NUMBER MODE] */ |
| public static final int KEYCODE_JP12_ZEN_NUM = -224; |
| /** Japanese 12-key keyboard [FULL-WIDTH ALPHABET MODE] */ |
| public static final int KEYCODE_JP12_ZEN_ALPHA = -225; |
| /** Japanese 12-key keyboard [FULL-WIDTH KATAKANA MODE] */ |
| public static final int KEYCODE_JP12_ZEN_KATA = -226; |
| /** Japanese 12-key keyboard [HALF-WIDTH KATAKANA MODE] */ |
| public static final int KEYCODE_JP12_HAN_KATA = -227; |
| /** Japanese 12-key keyboard [HALF-WIDTH NUMBER MODE] */ |
| public static final int KEYCODE_JP12_HAN_NUM = -228; |
| /** Japanese 12-key keyboard [HALF-WIDTH ALPHABET MODE] */ |
| public static final int KEYCODE_JP12_HAN_ALPHA = -229; |
| /** Japanese 12-key keyboard [MODE TOOGLE CHANGE] */ |
| public static final int KEYCODE_JP12_TOGGLE_MODE = -230; |
| |
| /** Key code for symbol keyboard alt key */ |
| public static final int KEYCODE_4KEY_MODE = -300; |
| /** Key code for symbol keyboard up key */ |
| public static final int KEYCODE_4KEY_UP = -301; |
| /** Key code for symbol keyboard down key */ |
| public static final int KEYCODE_4KEY_DOWN = -302; |
| /** Key code for symbol keyboard del key */ |
| public static final int KEYCODE_4KEY_CLEAR = -303; |
| |
| /* for Qwerty keyboard */ |
| /** Qwerty keyboard [DEL] */ |
| public static final int KEYCODE_QWERTY_BACKSPACE = -100; |
| /** Qwerty keyboard [ENTER] */ |
| public static final int KEYCODE_QWERTY_ENTER = -101; |
| /** Qwerty keyboard [SHIFT] */ |
| public static final int KEYCODE_QWERTY_SHIFT = Keyboard.KEYCODE_SHIFT; |
| /** Qwerty keyboard [ALT] */ |
| public static final int KEYCODE_QWERTY_ALT = -103; |
| /** Qwerty keyboard [KEYBOARD TYPE CHANGE] */ |
| public static final int KEYCODE_QWERTY_KBD = -104; |
| /** Qwerty keyboard [CLOSE] */ |
| public static final int KEYCODE_QWERTY_CLOSE = -105; |
| /** Japanese Qwerty keyboard [EMOJI] */ |
| public static final int KEYCODE_QWERTY_EMOJI = -106; |
| /** Japanese Qwerty keyboard [FULL-WIDTH HIRAGANA MODE] */ |
| public static final int KEYCODE_QWERTY_ZEN_HIRA = -107; |
| /** Japanese Qwerty keyboard [FULL-WIDTH NUMBER MODE] */ |
| public static final int KEYCODE_QWERTY_ZEN_NUM = -108; |
| /** Japanese Qwerty keyboard [FULL-WIDTH ALPHABET MODE] */ |
| public static final int KEYCODE_QWERTY_ZEN_ALPHA = -109; |
| /** Japanese Qwerty keyboard [FULL-WIDTH KATAKANA MODE] */ |
| public static final int KEYCODE_QWERTY_ZEN_KATA = -110; |
| /** Japanese Qwerty keyboard [HALF-WIDTH KATAKANA MODE] */ |
| public static final int KEYCODE_QWERTY_HAN_KATA = -111; |
| /** Qwerty keyboard [NUMBER MODE] */ |
| public static final int KEYCODE_QWERTY_HAN_NUM = -112; |
| /** Qwerty keyboard [ALPHABET MODE] */ |
| public static final int KEYCODE_QWERTY_HAN_ALPHA = -113; |
| /** Qwerty keyboard [MODE TOOGLE CHANGE] */ |
| public static final int KEYCODE_QWERTY_TOGGLE_MODE = -114; |
| /** Qwerty keyboard [PINYIN MODE] */ |
| public static final int KEYCODE_QWERTY_PINYIN = -115; |
| |
| /** OpenWnn instance which hold this software keyboard*/ |
| protected OpenWnn mWnn; |
| |
| /** Current keyboard view */ |
| protected KeyboardView mKeyboardView; |
| |
| /** View objects (main side) */ |
| protected BaseInputView mMainView; |
| /** View objects (sub side) */ |
| protected ViewGroup mSubView; |
| |
| /** Current keyboard definition */ |
| protected Keyboard mCurrentKeyboard; |
| |
| /** Caps lock state */ |
| protected boolean mCapsLock; |
| |
| /** Input restraint */ |
| protected boolean mDisableKeyInput = true; |
| /** |
| * Keyboard surfaces |
| * <br> |
| * Keyboard[language][portrait/landscape][keyboard type][shift off/on][key-mode] |
| */ |
| protected Keyboard[][][][][][] mKeyboard; |
| |
| /* languages */ |
| /** Current language */ |
| protected int mCurrentLanguage; |
| /** Language (English) */ |
| public static final int LANG_EN = 0; |
| /** Language (Japanese) */ |
| public static final int LANG_JA = 1; |
| /** Language (Chinese) */ |
| public static final int LANG_CN = 2; |
| |
| /* portrait/landscape */ |
| /** State of the display */ |
| protected int mDisplayMode = 0; |
| /** Display mode (Portrait) */ |
| public static final int PORTRAIT = 0; |
| /** Display mode (Landscape) */ |
| public static final int LANDSCAPE = 1; |
| |
| /* keyboard type */ |
| /** Current keyboard type */ |
| protected int mCurrentKeyboardType; |
| /** Keyboard (QWERTY keyboard) */ |
| public static final int KEYBOARD_QWERTY = 0; |
| /** Keyboard (12-keys keyboard) */ |
| public static final int KEYBOARD_12KEY = 1; |
| /** State of the shift key */ |
| protected int mShiftOn = 0; |
| /** Shift key off */ |
| public static final int KEYBOARD_SHIFT_OFF = 0; |
| /** Shift key on */ |
| public static final int KEYBOARD_SHIFT_ON = 1; |
| |
| /* key-modes */ |
| /** Current key-mode */ |
| protected int mCurrentKeyMode; |
| |
| /* key-modes for English */ |
| /** English key-mode (alphabet) */ |
| public static final int KEYMODE_EN_ALPHABET = 0; |
| /** English key-mode (number) */ |
| public static final int KEYMODE_EN_NUMBER = 1; |
| /** English key-mode (phone number) */ |
| public static final int KEYMODE_EN_PHONE = 2; |
| |
| /* key-modes for Japanese */ |
| /** Japanese key-mode (Full-width Hiragana) */ |
| public static final int KEYMODE_JA_FULL_HIRAGANA = 0; |
| /** Japanese key-mode (Full-width alphabet) */ |
| public static final int KEYMODE_JA_FULL_ALPHABET = 1; |
| /** Japanese key-mode (Full-width number) */ |
| public static final int KEYMODE_JA_FULL_NUMBER = 2; |
| /** Japanese key-mode (Full-width Katakana) */ |
| public static final int KEYMODE_JA_FULL_KATAKANA = 3; |
| /** Japanese key-mode (Half-width alphabet) */ |
| public static final int KEYMODE_JA_HALF_ALPHABET = 4; |
| /** Japanese key-mode (Half-width number) */ |
| public static final int KEYMODE_JA_HALF_NUMBER = 5; |
| /** Japanese key-mode (Half-width Katakana) */ |
| public static final int KEYMODE_JA_HALF_KATAKANA = 6; |
| /** Japanese key-mode (Half-width phone number) */ |
| public static final int KEYMODE_JA_HALF_PHONE = 7; |
| |
| /* key-modes for Chinese */ |
| /** Chinese key-mode (pinyin) */ |
| public static final int KEYMODE_CN_PINYIN = 0; |
| /** Chinese key-mode (Full-width number) */ |
| public static final int KEYMODE_CN_FULL_NUMBER = 1; |
| /** Chinese key-mode (alphabet) */ |
| public static final int KEYMODE_CN_ALPHABET = 2; |
| /** Chinese key-mode (phone) */ |
| public static final int KEYMODE_CN_PHONE = 3; |
| /** Chinese key-mode (Half-width number) */ |
| public static final int KEYMODE_CN_HALF_NUMBER = 4; |
| |
| /* key-modes for HARD */ |
| /** HARD key-mode (SHIFT_OFF_ALT_OFF) */ |
| public static final int HARD_KEYMODE_SHIFT_OFF_ALT_OFF = 2; |
| /** HARD key-mode (SHIFT_ON_ALT_OFF) */ |
| public static final int HARD_KEYMODE_SHIFT_ON_ALT_OFF = 3; |
| /** HARD key-mode (SHIFT_OFF_ALT_ON) */ |
| public static final int HARD_KEYMODE_SHIFT_OFF_ALT_ON = 4; |
| /** HARD key-mode (SHIFT_ON_ALT_ON) */ |
| public static final int HARD_KEYMODE_SHIFT_ON_ALT_ON = 5; |
| /** HARD key-mode (SHIFT_LOCK_ALT_OFF) */ |
| public static final int HARD_KEYMODE_SHIFT_LOCK_ALT_OFF = 6; |
| /** HARD key-mode (SHIFT_LOCK_ALT_ON) */ |
| public static final int HARD_KEYMODE_SHIFT_LOCK_ALT_ON = 7; |
| /** HARD key-mode (SHIFT_LOCK_ALT_LOCK) */ |
| public static final int HARD_KEYMODE_SHIFT_LOCK_ALT_LOCK = 8; |
| /** HARD key-mode (SHIFT_OFF_ALT_LOCK) */ |
| public static final int HARD_KEYMODE_SHIFT_OFF_ALT_LOCK = 9; |
| /** HARD key-mode (SHIFT_ON_ALT_LOCK) */ |
| public static final int HARD_KEYMODE_SHIFT_ON_ALT_LOCK = 10; |
| |
| /** Whether the H/W keyboard is hidden. */ |
| protected boolean mHardKeyboardHidden = true; |
| |
| /** Whether the H/W 12key keyboard. */ |
| protected boolean mEnableHardware12Keyboard = false; |
| |
| /** Symbol keyboard */ |
| protected Keyboard mSymbolKeyboard; |
| |
| /** Symbol keyboard state */ |
| protected boolean mIsSymbolKeyboard = false; |
| |
| /** |
| * Status of the composing text |
| * <br> |
| * {@code true} if there is no composing text. |
| */ |
| protected boolean mNoInput = true; |
| |
| /** Vibratior for key click vibration */ |
| protected Vibrator mVibrator = null; |
| |
| /** MediaPlayer for key click sound */ |
| protected MediaPlayer mSound = null; |
| |
| /** Key toggle cycle table currently using */ |
| protected String[] mCurrentCycleTable; |
| |
| /** Event listener for symbol keyboard */ |
| private OnKeyboardActionListener mSymbolOnKeyboardAction = new OnKeyboardActionListener() { |
| public void onKey(int primaryCode, int[] keyCodes) { |
| switch (primaryCode) { |
| case KEYCODE_4KEY_MODE: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK))); |
| break; |
| |
| case KEYCODE_4KEY_UP: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CANDIDATE_VIEW_SCROLL_UP)); |
| break; |
| |
| case KEYCODE_4KEY_DOWN: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CANDIDATE_VIEW_SCROLL_DOWN)); |
| break; |
| |
| case KEYCODE_4KEY_CLEAR: |
| InputConnection connection = mWnn.getCurrentInputConnection(); |
| if (connection != null) { |
| connection.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL)); |
| } |
| return; |
| |
| default: |
| break; |
| } |
| } |
| public void onPress(int primaryCode) { |
| playSoundAndVibration(); |
| } |
| public void onText(CharSequence text) { } |
| public void swipeLeft() { } |
| public void swipeRight() { } |
| public void swipeUp() { } |
| public void swipeDown() { } |
| public void onRelease(int primaryCode) { } |
| public boolean onLongPress(Keyboard.Key key) { |
| switch (key.codes[0]) { |
| case KEYCODE_4KEY_UP: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CANDIDATE_VIEW_SCROLL_FULL_UP)); |
| return true; |
| |
| case KEYCODE_4KEY_DOWN: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CANDIDATE_VIEW_SCROLL_FULL_DOWN)); |
| return true; |
| |
| default: |
| break; |
| } |
| return false; |
| } |
| }; |
| |
| /** |
| * Constructor |
| */ |
| public DefaultSoftKeyboard() { } |
| |
| /** |
| * Create keyboard views |
| * |
| * @param parent OpenWnn using the keyboards. |
| */ |
| protected void createKeyboards(OpenWnn parent) { |
| /* |
| * Keyboard[# of Languages][portrait/landscape][# of keyboard type] |
| * [shift off/on][max # of key-modes][non-input/input] |
| */ |
| mKeyboard = new Keyboard[3][2][4][2][7][2]; |
| } |
| |
| /** |
| * Get the keyboard changed the specified shift state. |
| * |
| * @param shift Shift state |
| * @return Keyboard view |
| */ |
| protected Keyboard getShiftChangeKeyboard(int shift) { |
| try { |
| Keyboard[] kbd = mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][shift][mCurrentKeyMode]; |
| |
| if (!mNoInput && kbd[1] != null) { |
| return kbd[1]; |
| } |
| return kbd[0]; |
| } catch (Exception ex) { |
| return null; |
| } |
| } |
| |
| /** |
| * Get the keyboard changed the specified input mode. |
| * |
| * @param mode Input mode |
| * @return Keyboard view |
| */ |
| protected Keyboard getModeChangeKeyboard(int mode) { |
| try { |
| Keyboard[] kbd = mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mode]; |
| |
| if (!mNoInput && kbd[1] != null) { |
| return kbd[1]; |
| } |
| return kbd[0]; |
| } catch (Exception ex) { |
| return null; |
| } |
| } |
| |
| /** |
| * Get the keyboard changed the specified keyboard type |
| * |
| * @param type Keyboard type |
| * @return Keyboard view |
| */ |
| protected Keyboard getTypeChangeKeyboard(int type) { |
| try { |
| Keyboard[] kbd = mKeyboard[mCurrentLanguage][mDisplayMode][type][mShiftOn][mCurrentKeyMode]; |
| |
| if (!mNoInput && kbd[1] != null) { |
| return kbd[1]; |
| } |
| return kbd[0]; |
| } catch (Exception ex) { |
| return null; |
| } |
| } |
| |
| /** |
| * Get the keyboard when some characters are input or no character is input. |
| * |
| * @param inputed {@code true} if some characters are inputed; {@code false} if no character is inputed. |
| * @return Keyboard view |
| */ |
| protected Keyboard getKeyboardInputed(boolean inputed) { |
| try { |
| Keyboard[] kbd = mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mCurrentKeyMode]; |
| |
| if (inputed && kbd[1] != null) { |
| return kbd[1]; |
| } |
| return kbd[0]; |
| } catch (Exception ex) { |
| return null; |
| } |
| } |
| |
| /** |
| * Change the circulative key-mode. |
| */ |
| protected void toggleKeyMode() { |
| /* unlock shift */ |
| mShiftOn = KEYBOARD_SHIFT_OFF; |
| |
| /* search next defined key-mode */ |
| Keyboard[][] keyboardList = mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn]; |
| do { |
| if (++mCurrentKeyMode >= keyboardList.length) { |
| mCurrentKeyMode = 0; |
| } |
| } while (keyboardList[mCurrentKeyMode][0] == null); |
| |
| Keyboard kbd; |
| if (!mNoInput && keyboardList[mCurrentKeyMode][1] != null) { |
| kbd = keyboardList[mCurrentKeyMode][1]; |
| } else { |
| kbd = keyboardList[mCurrentKeyMode][0]; |
| } |
| changeKeyboard(kbd); |
| |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnEvent.Mode.DEFAULT)); |
| } |
| |
| /** |
| * Toggle change the shift lock state. |
| */ |
| protected void toggleShiftLock() { |
| if (mShiftOn == 0) { |
| /* turn shift on */ |
| Keyboard newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_ON); |
| if (newKeyboard != null) { |
| mShiftOn = 1; |
| changeKeyboard(newKeyboard); |
| } |
| mCapsLock = true; |
| } else { |
| /* turn shift off */ |
| Keyboard newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_OFF); |
| if (newKeyboard != null) { |
| mShiftOn = 0; |
| changeKeyboard(newKeyboard); |
| } |
| mCapsLock = false; |
| } |
| } |
| |
| /** |
| * Handling Alt key event. |
| */ |
| protected void processAltKey() { |
| /* invalid if it is not qwerty mode */ |
| if (mCurrentKeyboardType != KEYBOARD_QWERTY) { |
| return; |
| } |
| |
| int mode = -1; |
| int keymode = mCurrentKeyMode; |
| switch (mCurrentLanguage) { |
| case LANG_EN: |
| if (keymode == KEYMODE_EN_ALPHABET) { |
| mode = KEYMODE_EN_NUMBER; |
| } else if (keymode == KEYMODE_EN_NUMBER) { |
| mode = KEYMODE_EN_ALPHABET; |
| } |
| break; |
| |
| case LANG_JA: |
| if (keymode == KEYMODE_JA_HALF_ALPHABET) { |
| mode = KEYMODE_JA_HALF_NUMBER; |
| } else if (keymode == KEYMODE_JA_HALF_NUMBER) { |
| mode = KEYMODE_JA_HALF_ALPHABET; |
| } else if (keymode == KEYMODE_JA_FULL_ALPHABET) { |
| mode = KEYMODE_JA_FULL_NUMBER; |
| } else if (keymode == KEYMODE_JA_FULL_NUMBER) { |
| mode = KEYMODE_JA_FULL_ALPHABET; |
| } |
| break; |
| |
| default: |
| /* invalid */ |
| } |
| |
| if (mode >= 0) { |
| Keyboard kbd = getModeChangeKeyboard(mode); |
| if (kbd != null) { |
| mCurrentKeyMode = mode; |
| changeKeyboard(kbd); |
| } |
| } |
| } |
| |
| /** |
| * Change the keyboard type. |
| * |
| * @param type Type of the keyboard |
| * @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#KEYBOARD_QWERTY |
| * @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#KEYBOARD_12KEY |
| */ |
| public void changeKeyboardType(int type) { |
| /* ignore invalid parameter */ |
| if (type != KEYBOARD_QWERTY && type != KEYBOARD_12KEY) { |
| return; |
| } |
| |
| /* change keyboard view */ |
| Keyboard kbd = getTypeChangeKeyboard(type); |
| if (kbd != null) { |
| mCurrentKeyboardType = type; |
| changeKeyboard(kbd); |
| } |
| |
| /* notice that the keyboard is changed */ |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnEvent.Mode.DEFAULT)); |
| } |
| |
| /** |
| * Change the keyboard. |
| * |
| * @param keyboard The new keyboard |
| * @return {@code true} if the keyboard is changed; {@code false} if not changed. |
| */ |
| protected boolean changeKeyboard(Keyboard keyboard) { |
| |
| if (keyboard == null) { |
| return false; |
| } |
| if (mCurrentKeyboard != keyboard) { |
| mKeyboardView.setKeyboard(keyboard); |
| mKeyboardView.setShifted((mShiftOn == 0) ? false : true); |
| mCurrentKeyboard = keyboard; |
| return true; |
| } else { |
| mKeyboardView.setShifted((mShiftOn == 0) ? false : true); |
| return false; |
| } |
| } |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#initView */ |
| public View initView(OpenWnn parent, int width, int height) { |
| mWnn = parent; |
| mDisplayMode = |
| (parent.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) |
| ? LANDSCAPE : PORTRAIT; |
| |
| /* |
| * create keyboards & the view. |
| * To re-display the input view when the display mode is changed portrait <-> landscape, |
| * create keyboards every time. |
| */ |
| createKeyboards(parent); |
| |
| /* create symbol keyboard */ |
| mSymbolKeyboard = new Keyboard(parent, R.xml.keyboard_4key); |
| |
| SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(parent); |
| String skin = pref.getString("keyboard_skin", |
| mWnn.getResources().getString(R.string.keyboard_skin_id_default)); |
| int id = parent.getResources().getIdentifier(skin, "layout", "jp.co.omronsoft.openwnn"); |
| |
| mKeyboardView = (KeyboardView) mWnn.getLayoutInflater().inflate(id, null); |
| mKeyboardView.setOnKeyboardActionListener(this); |
| mCurrentKeyboard = null; |
| |
| mMainView = (BaseInputView) parent.getLayoutInflater().inflate(R.layout.keyboard_default_main, null); |
| mSubView = (ViewGroup) parent.getLayoutInflater().inflate(R.layout.keyboard_default_sub, null); |
| |
| if (!mHardKeyboardHidden) { |
| if (!mEnableHardware12Keyboard) { |
| mMainView.addView(mSubView); |
| } |
| } else if (mKeyboardView != null) { |
| mMainView.addView(mKeyboardView); |
| } |
| |
| return mMainView; |
| } |
| |
| /** |
| * Update the SHFIT/ALT keys indicator. |
| * |
| * @param mode The state of SHIFT/ALT keys. |
| */ |
| public void updateIndicator(int mode) { |
| Resources res = mWnn.getResources(); |
| TextView text1 = (TextView)mSubView.findViewById(R.id.shift); |
| TextView text2 = (TextView)mSubView.findViewById(R.id.alt); |
| |
| switch (mode) { |
| case HARD_KEYMODE_SHIFT_OFF_ALT_OFF: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_off)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_off)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_ON_ALT_OFF: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_on)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_off)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_LOCK_ALT_OFF: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_lock)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_off)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_background_lock_caps)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_OFF_ALT_ON: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_off)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_on)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_OFF_ALT_LOCK: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_off)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_lock)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_background_lock_alt)); |
| break; |
| case HARD_KEYMODE_SHIFT_ON_ALT_ON: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_on)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_on)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_ON_ALT_LOCK: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_on)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_lock)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_background_lock_alt)); |
| break; |
| case HARD_KEYMODE_SHIFT_LOCK_ALT_ON: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_lock)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_on)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_background_lock_caps)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| case HARD_KEYMODE_SHIFT_LOCK_ALT_LOCK: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_lock)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_lock)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_background_lock_caps)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_background_lock_alt)); |
| break; |
| default: |
| text1.setTextColor(res.getColor(R.color.indicator_textcolor_caps_off)); |
| text2.setTextColor(res.getColor(R.color.indicator_textcolor_alt_off)); |
| text1.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| text2.setBackgroundColor(res.getColor(R.color.indicator_textbackground_default)); |
| break; |
| } |
| return; |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#getCurrentView */ |
| public View getCurrentView() { |
| return mMainView; |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#onUpdateState */ |
| public void onUpdateState(OpenWnn parent) { |
| try { |
| if (parent.mComposingText.size(1) == 0) { |
| if (!mNoInput) { |
| /* when the mode changed to "no input" */ |
| mNoInput = true; |
| Keyboard newKeyboard = getKeyboardInputed(false); |
| if (mCurrentKeyboard != newKeyboard) { |
| changeKeyboard(newKeyboard); |
| } |
| } |
| } else { |
| if (mNoInput) { |
| /* when the mode changed to "input some characters" */ |
| mNoInput = false; |
| Keyboard newKeyboard = getKeyboardInputed(true); |
| if (mCurrentKeyboard != newKeyboard) { |
| changeKeyboard(newKeyboard); |
| } |
| } |
| } |
| } catch (Exception ex) { |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#setPreferences */ |
| public void setPreferences(SharedPreferences pref, EditorInfo editor) { |
| |
| /* vibrator */ |
| try { |
| if (pref.getBoolean("key_vibration", false)) { |
| mVibrator = (Vibrator)mWnn.getSystemService(Context.VIBRATOR_SERVICE); |
| } else { |
| mVibrator = null; |
| } |
| } catch (Exception ex) { |
| Log.d("OpenWnn", "NO VIBRATOR"); |
| } |
| |
| /* sound */ |
| try { |
| if (pref.getBoolean("key_sound", false)) { |
| mSound = MediaPlayer.create(mWnn, R.raw.type); |
| } else { |
| mSound = null; |
| } |
| } catch (Exception ex) { |
| Log.d("OpenWnn", "NO SOUND"); |
| } |
| |
| /* pop-up preview */ |
| if (OpenWnn.isXLarge()) { |
| mKeyboardView.setPreviewEnabled(false); |
| } else { |
| mKeyboardView.setPreviewEnabled(pref.getBoolean("popup_preview", true)); |
| mKeyboardView.clearWindowInfo(); |
| } |
| |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#closing */ |
| public void closing() { |
| if (mKeyboardView != null) { |
| mKeyboardView.closing(); |
| } |
| mDisableKeyInput = true; |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#showInputView */ |
| public void showInputView() { |
| if (mKeyboardView != null) { |
| mKeyboardView.setVisibility(View.VISIBLE); |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.InputViewManager#hideInputView */ |
| public void hideInputView() { |
| mKeyboardView.setVisibility(View.GONE); |
| } |
| |
| /*********************************************************************** |
| * onKeyboardActionListener |
| ***********************************************************************/ |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#onKey */ |
| public void onKey(int primaryCode, int[] keyCodes) { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#swipeRight */ |
| public void swipeRight() { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#swipeLeft */ |
| public void swipeLeft() { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#swipeDown */ |
| public void swipeDown() { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#swipeUp */ |
| public void swipeUp() { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#onRelease */ |
| public void onRelease(int x) { } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#onPress */ |
| public void onPress(int x) { |
| playSoundAndVibration(); |
| } |
| |
| /** @see android.jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#onLongPress */ |
| public boolean onLongPress(Keyboard.Key key) { |
| return false; |
| } |
| |
| /** |
| * Play sound & vibration. |
| */ |
| private void playSoundAndVibration() { |
| /* key click sound & vibration */ |
| if (mVibrator != null) { |
| try { mVibrator.vibrate(5); } catch (Exception ex) { } |
| } |
| if (mSound != null) { |
| try { mSound.seekTo(0); mSound.start(); } catch (Exception ex) { } |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.KeyboardView.OnKeyboardActionListener#onText */ |
| public void onText(CharSequence text) {} |
| |
| /** |
| * Get current key mode. |
| * |
| * @return Current key mode |
| */ |
| public int getKeyMode() { |
| return mCurrentKeyMode; |
| } |
| |
| /** |
| * Get current keyboard type. |
| * |
| * @return Current keyboard type |
| */ |
| public int getKeyboardType() { |
| return mCurrentKeyboardType; |
| } |
| |
| /** |
| * Set the H/W keyboard's state. |
| * |
| * @param hidden {@code true} if hidden. |
| */ |
| public void setHardKeyboardHidden(boolean hidden) { |
| mHardKeyboardHidden = hidden; |
| } |
| |
| /** |
| * Set the H/W keyboard's type. |
| * |
| * @param type12Key {@code true} if 12Key. |
| */ |
| public void setHardware12Keyboard(boolean type12Key) { |
| mEnableHardware12Keyboard = type12Key; |
| } |
| |
| /** |
| * Get current keyboard view. |
| */ |
| public View getKeyboardView() { |
| return mKeyboardView; |
| } |
| |
| /** |
| * Reset the current keyboard |
| */ |
| public void resetCurrentKeyboard() { |
| closing(); |
| Keyboard keyboard = mCurrentKeyboard; |
| mCurrentKeyboard = null; |
| changeKeyboard(keyboard); |
| } |
| |
| /** |
| * Set the normal keyboard. |
| */ |
| public void setNormalKeyboard() { |
| if (mCurrentKeyboard == null) { |
| return; |
| } |
| mKeyboardView.setKeyboard(mCurrentKeyboard); |
| mKeyboardView.setOnKeyboardActionListener(this); |
| mIsSymbolKeyboard = false; |
| } |
| |
| /** |
| * Set the symbol keyboard. |
| */ |
| public void setSymbolKeyboard() { |
| mKeyboardView.setKeyboard(mSymbolKeyboard); |
| mKeyboardView.setOnKeyboardActionListener(mSymbolOnKeyboardAction); |
| mIsSymbolKeyboard = true; |
| } |
| } |
