| /* |
| * 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.JAJP; |
| |
| import android.app.AlertDialog; |
| import jp.co.omronsoft.openwnn.*; |
| import android.content.DialogInterface; |
| import android.content.res.Resources; |
| import android.view.KeyEvent; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputConnection; |
| import android.util.Log; |
| import android.view.View; |
| import android.content.SharedPreferences; |
| |
| import jp.co.omronsoft.openwnn.Keyboard; |
| import jp.co.omronsoft.openwnn.BaseInputView; |
| import jp.co.omronsoft.openwnn.R; |
| |
| import java.util.HashMap; |
| import java.util.Locale; |
| import java.util.List; |
| |
| /** |
| * The default Software Keyboard class for Japanese IME. |
| * |
| * @author Copyright (C) 2009 OMRON SOFTWARE CO., LTD. All Rights Reserved. |
| */ |
| public class DefaultSoftKeyboardJAJP extends DefaultSoftKeyboard { |
| /** Enable English word prediction on half-width alphabet mode */ |
| private static final boolean USE_ENGLISH_PREDICT = true; |
| |
| /** Key code for switching to full-width HIRAGANA mode */ |
| private static final int KEYCODE_SWITCH_FULL_HIRAGANA = -301; |
| |
| /** Key code for switching to full-width KATAKANA mode */ |
| private static final int KEYCODE_SWITCH_FULL_KATAKANA = -302; |
| |
| /** Key code for switching to full-width alphabet mode */ |
| private static final int KEYCODE_SWITCH_FULL_ALPHABET = -303; |
| |
| /** Key code for switching to full-width number mode */ |
| private static final int KEYCODE_SWITCH_FULL_NUMBER = -304; |
| |
| /** Key code for switching to half-width KATAKANA mode */ |
| private static final int KEYCODE_SWITCH_HALF_KATAKANA = -306; |
| |
| /** Key code for switching to half-width alphabet mode */ |
| private static final int KEYCODE_SWITCH_HALF_ALPHABET = -307; |
| |
| /** Key code for switching to half-width number mode */ |
| private static final int KEYCODE_SWITCH_HALF_NUMBER = -308; |
| |
| /** Key code for case toggle key */ |
| private static final int KEYCODE_SELECT_CASE = -309; |
| |
| /** Key code for EISU-KANA conversion */ |
| private static final int KEYCODE_EISU_KANA = -305; |
| |
| /** Key code for NOP (no-operation) */ |
| private static final int KEYCODE_NOP = -310; |
| |
| |
| /** Input mode toggle cycle table */ |
| private static final int[] JP_MODE_CYCLE_TABLE = { |
| KEYMODE_JA_FULL_HIRAGANA, KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER |
| }; |
| |
| /** Definition for {@code mInputType} (toggle) */ |
| private static final int INPUT_TYPE_TOGGLE = 1; |
| |
| /** Definition for {@code mInputType} (commit instantly) */ |
| private static final int INPUT_TYPE_INSTANT = 2; |
| |
| /** Max key number of the 12 key keyboard (depends on the definition of keyboards) */ |
| private static final int KEY_NUMBER_12KEY = 20; |
| |
| /** Toggle cycle table for full-width HIRAGANA */ |
| private static final String[][] JP_FULL_HIRAGANA_CYCLE_TABLE = { |
| {"\u3042", "\u3044", "\u3046", "\u3048", "\u304a", "\u3041", "\u3043", "\u3045", "\u3047", "\u3049"}, |
| {"\u304b", "\u304d", "\u304f", "\u3051", "\u3053"}, |
| {"\u3055", "\u3057", "\u3059", "\u305b", "\u305d"}, |
| {"\u305f", "\u3061", "\u3064", "\u3066", "\u3068", "\u3063"}, |
| {"\u306a", "\u306b", "\u306c", "\u306d", "\u306e"}, |
| {"\u306f", "\u3072", "\u3075", "\u3078", "\u307b"}, |
| {"\u307e", "\u307f", "\u3080", "\u3081", "\u3082"}, |
| {"\u3084", "\u3086", "\u3088", "\u3083", "\u3085", "\u3087"}, |
| {"\u3089", "\u308a", "\u308b", "\u308c", "\u308d"}, |
| {"\u308f", "\u3092", "\u3093", "\u308e", "\u30fc"}, |
| {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"}, |
| }; |
| |
| /** Replace table for full-width HIRAGANA */ |
| private static final HashMap<String, String> JP_FULL_HIRAGANA_REPLACE_TABLE = new HashMap<String, String>() {{ |
| put("\u3042", "\u3041"); put("\u3044", "\u3043"); put("\u3046", "\u3045"); put("\u3048", "\u3047"); put("\u304a", "\u3049"); |
| put("\u3041", "\u3042"); put("\u3043", "\u3044"); put("\u3045", "\u30f4"); put("\u3047", "\u3048"); put("\u3049", "\u304a"); |
| put("\u304b", "\u304c"); put("\u304d", "\u304e"); put("\u304f", "\u3050"); put("\u3051", "\u3052"); put("\u3053", "\u3054"); |
| put("\u304c", "\u304b"); put("\u304e", "\u304d"); put("\u3050", "\u304f"); put("\u3052", "\u3051"); put("\u3054", "\u3053"); |
| put("\u3055", "\u3056"); put("\u3057", "\u3058"); put("\u3059", "\u305a"); put("\u305b", "\u305c"); put("\u305d", "\u305e"); |
| put("\u3056", "\u3055"); put("\u3058", "\u3057"); put("\u305a", "\u3059"); put("\u305c", "\u305b"); put("\u305e", "\u305d"); |
| put("\u305f", "\u3060"); put("\u3061", "\u3062"); put("\u3064", "\u3063"); put("\u3066", "\u3067"); put("\u3068", "\u3069"); |
| put("\u3060", "\u305f"); put("\u3062", "\u3061"); put("\u3063", "\u3065"); put("\u3067", "\u3066"); put("\u3069", "\u3068"); |
| put("\u3065", "\u3064"); put("\u30f4", "\u3046"); |
| put("\u306f", "\u3070"); put("\u3072", "\u3073"); put("\u3075", "\u3076"); put("\u3078", "\u3079"); put("\u307b", "\u307c"); |
| put("\u3070", "\u3071"); put("\u3073", "\u3074"); put("\u3076", "\u3077"); put("\u3079", "\u307a"); put("\u307c", "\u307d"); |
| put("\u3071", "\u306f"); put("\u3074", "\u3072"); put("\u3077", "\u3075"); put("\u307a", "\u3078"); put("\u307d", "\u307b"); |
| put("\u3084", "\u3083"); put("\u3086", "\u3085"); put("\u3088", "\u3087"); |
| put("\u3083", "\u3084"); put("\u3085", "\u3086"); put("\u3087", "\u3088"); |
| put("\u308f", "\u308e"); |
| put("\u308e", "\u308f"); |
| put("\u309b", "\u309c"); |
| put("\u309c", "\u309b"); |
| }}; |
| |
| /** Toggle cycle table for full-width KATAKANA */ |
| private static final String[][] JP_FULL_KATAKANA_CYCLE_TABLE = { |
| {"\u30a2", "\u30a4", "\u30a6", "\u30a8", "\u30aa", "\u30a1", "\u30a3", |
| "\u30a5", "\u30a7", "\u30a9"}, |
| {"\u30ab", "\u30ad", "\u30af", "\u30b1", "\u30b3"}, |
| {"\u30b5", "\u30b7", "\u30b9", "\u30bb", "\u30bd"}, |
| {"\u30bf", "\u30c1", "\u30c4", "\u30c6", "\u30c8", "\u30c3"}, |
| {"\u30ca", "\u30cb", "\u30cc", "\u30cd", "\u30ce"}, |
| {"\u30cf", "\u30d2", "\u30d5", "\u30d8", "\u30db"}, |
| {"\u30de", "\u30df", "\u30e0", "\u30e1", "\u30e2"}, |
| {"\u30e4", "\u30e6", "\u30e8", "\u30e3", "\u30e5", "\u30e7"}, |
| {"\u30e9", "\u30ea", "\u30eb", "\u30ec", "\u30ed"}, |
| {"\u30ef", "\u30f2", "\u30f3", "\u30ee", "\u30fc"}, |
| {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"} |
| }; |
| |
| /** Replace table for full-width KATAKANA */ |
| private static final HashMap<String,String> JP_FULL_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{ |
| put("\u30a2", "\u30a1"); put("\u30a4", "\u30a3"); put("\u30a6", "\u30a5"); put("\u30a8", "\u30a7"); put("\u30aa", "\u30a9"); |
| put("\u30a1", "\u30a2"); put("\u30a3", "\u30a4"); put("\u30a5", "\u30f4"); put("\u30a7", "\u30a8"); put("\u30a9", "\u30aa"); |
| put("\u30ab", "\u30ac"); put("\u30ad", "\u30ae"); put("\u30af", "\u30b0"); put("\u30b1", "\u30b2"); put("\u30b3", "\u30b4"); |
| put("\u30ac", "\u30ab"); put("\u30ae", "\u30ad"); put("\u30b0", "\u30af"); put("\u30b2", "\u30b1"); put("\u30b4", "\u30b3"); |
| put("\u30b5", "\u30b6"); put("\u30b7", "\u30b8"); put("\u30b9", "\u30ba"); put("\u30bb", "\u30bc"); put("\u30bd", "\u30be"); |
| put("\u30b6", "\u30b5"); put("\u30b8", "\u30b7"); put("\u30ba", "\u30b9"); put("\u30bc", "\u30bb"); put("\u30be", "\u30bd"); |
| put("\u30bf", "\u30c0"); put("\u30c1", "\u30c2"); put("\u30c4", "\u30c3"); put("\u30c6", "\u30c7"); put("\u30c8", "\u30c9"); |
| put("\u30c0", "\u30bf"); put("\u30c2", "\u30c1"); put("\u30c3", "\u30c5"); put("\u30c7", "\u30c6"); put("\u30c9", "\u30c8"); |
| put("\u30c5", "\u30c4"); put("\u30f4", "\u30a6"); |
| put("\u30cf", "\u30d0"); put("\u30d2", "\u30d3"); put("\u30d5", "\u30d6"); put("\u30d8", "\u30d9"); put("\u30db", "\u30dc"); |
| put("\u30d0", "\u30d1"); put("\u30d3", "\u30d4"); put("\u30d6", "\u30d7"); put("\u30d9", "\u30da"); put("\u30dc", "\u30dd"); |
| put("\u30d1", "\u30cf"); put("\u30d4", "\u30d2"); put("\u30d7", "\u30d5"); put("\u30da", "\u30d8"); put("\u30dd", "\u30db"); |
| put("\u30e4", "\u30e3"); put("\u30e6", "\u30e5"); put("\u30e8", "\u30e7"); |
| put("\u30e3", "\u30e4"); put("\u30e5", "\u30e6"); put("\u30e7", "\u30e8"); |
| put("\u30ef", "\u30ee"); |
| put("\u30ee", "\u30ef"); |
| }}; |
| |
| /** Toggle cycle table for half-width KATAKANA */ |
| private static final String[][] JP_HALF_KATAKANA_CYCLE_TABLE = { |
| {"\uff71", "\uff72", "\uff73", "\uff74", "\uff75", "\uff67", "\uff68", "\uff69", "\uff6a", "\uff6b"}, |
| {"\uff76", "\uff77", "\uff78", "\uff79", "\uff7a"}, |
| {"\uff7b", "\uff7c", "\uff7d", "\uff7e", "\uff7f"}, |
| {"\uff80", "\uff81", "\uff82", "\uff83", "\uff84", "\uff6f"}, |
| {"\uff85", "\uff86", "\uff87", "\uff88", "\uff89"}, |
| {"\uff8a", "\uff8b", "\uff8c", "\uff8d", "\uff8e"}, |
| {"\uff8f", "\uff90", "\uff91", "\uff92", "\uff93"}, |
| {"\uff94", "\uff95", "\uff96", "\uff6c", "\uff6d", "\uff6e"}, |
| {"\uff97", "\uff98", "\uff99", "\uff9a", "\uff9b"}, |
| {"\uff9c", "\uff66", "\uff9d", "\uff70"}, |
| {"\uff64", "\uff61", "?", "!", "\uff65", " "}, |
| }; |
| |
| /** Replace table for half-width KATAKANA */ |
| private static final HashMap<String,String> JP_HALF_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{ |
| put("\uff71", "\uff67"); put("\uff72", "\uff68"); put("\uff73", "\uff69"); put("\uff74", "\uff6a"); put("\uff75", "\uff6b"); |
| put("\uff67", "\uff71"); put("\uff68", "\uff72"); put("\uff69", "\uff73\uff9e"); put("\uff6a", "\uff74"); put("\uff6b", "\uff75"); |
| put("\uff76", "\uff76\uff9e"); put("\uff77", "\uff77\uff9e"); put("\uff78", "\uff78\uff9e"); put("\uff79", "\uff79\uff9e"); put("\uff7a", "\uff7a\uff9e"); |
| put("\uff76\uff9e", "\uff76"); put("\uff77\uff9e", "\uff77"); put("\uff78\uff9e", "\uff78"); put("\uff79\uff9e", "\uff79"); put("\uff7a\uff9e", "\uff7a"); |
| put("\uff7b", "\uff7b\uff9e"); put("\uff7c", "\uff7c\uff9e"); put("\uff7d", "\uff7d\uff9e"); put("\uff7e", "\uff7e\uff9e"); put("\uff7f", "\uff7f\uff9e"); |
| put("\uff7b\uff9e", "\uff7b"); put("\uff7c\uff9e", "\uff7c"); put("\uff7d\uff9e", "\uff7d"); put("\uff7e\uff9e", "\uff7e"); put("\uff7f\uff9e", "\uff7f"); |
| put("\uff80", "\uff80\uff9e"); put("\uff81", "\uff81\uff9e"); put("\uff82", "\uff6f"); put("\uff83", "\uff83\uff9e"); put("\uff84", "\uff84\uff9e"); |
| put("\uff80\uff9e", "\uff80"); put("\uff81\uff9e", "\uff81"); put("\uff6f", "\uff82\uff9e"); put("\uff83\uff9e", "\uff83"); put("\uff84\uff9e", "\uff84"); |
| put("\uff82\uff9e", "\uff82"); |
| put("\uff8a", "\uff8a\uff9e"); put("\uff8b", "\uff8b\uff9e"); put("\uff8c", "\uff8c\uff9e"); put("\uff8d", "\uff8d\uff9e"); put("\uff8e", "\uff8e\uff9e"); |
| put("\uff8a\uff9e", "\uff8a\uff9f");put("\uff8b\uff9e", "\uff8b\uff9f");put("\uff8c\uff9e", "\uff8c\uff9f");put("\uff8d\uff9e", "\uff8d\uff9f");put("\uff8e\uff9e", "\uff8e\uff9f"); |
| put("\uff8a\uff9f", "\uff8a"); put("\uff8b\uff9f", "\uff8b"); put("\uff8c\uff9f", "\uff8c"); put("\uff8d\uff9f", "\uff8d"); put("\uff8e\uff9f", "\uff8e"); |
| put("\uff94", "\uff6c"); put("\uff95", "\uff6d"); put("\uff96", "\uff6e"); |
| put("\uff6c", "\uff94"); put("\uff6d", "\uff95"); put("\uff6e", "\uff96"); |
| put("\uff9c", "\uff9c"); put("\uff73\uff9e", "\uff73"); |
| }}; |
| |
| /** Toggle cycle table for full-width alphabet */ |
| private static final String[][] JP_FULL_ALPHABET_CYCLE_TABLE = { |
| {"\uff0e", "\uff20", "\uff0d", "\uff3f", "\uff0f", "\uff1a", "\uff5e", "\uff11"}, |
| {"\uff41", "\uff42", "\uff43", "\uff21", "\uff22", "\uff23", "\uff12"}, |
| {"\uff44", "\uff45", "\uff46", "\uff24", "\uff25", "\uff26", "\uff13"}, |
| {"\uff47", "\uff48", "\uff49", "\uff27", "\uff28", "\uff29", "\uff14"}, |
| {"\uff4a", "\uff4b", "\uff4c", "\uff2a", "\uff2b", "\uff2c", "\uff15"}, |
| {"\uff4d", "\uff4e", "\uff4f", "\uff2d", "\uff2e", "\uff2f", "\uff16"}, |
| {"\uff50", "\uff51", "\uff52", "\uff53", "\uff30", "\uff31", "\uff32", "\uff33", "\uff17"}, |
| {"\uff54", "\uff55", "\uff56", "\uff34", "\uff35", "\uff36", "\uff18"}, |
| {"\uff57", "\uff58", "\uff59", "\uff5a", "\uff37", "\uff38", "\uff39", "\uff3a", "\uff19"}, |
| {"\uff0d", "\uff10"}, |
| {"\uff0c", "\uff0e", "\uff1f", "\uff01", "\u30fb", "\u3000"} |
| }; |
| |
| /** Replace table for full-width alphabet */ |
| private static final HashMap<String,String> JP_FULL_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{ |
| put("\uff21", "\uff41"); put("\uff22", "\uff42"); put("\uff23", "\uff43"); put("\uff24", "\uff44"); put("\uff25", "\uff45"); |
| put("\uff41", "\uff21"); put("\uff42", "\uff22"); put("\uff43", "\uff23"); put("\uff44", "\uff24"); put("\uff45", "\uff25"); |
| put("\uff26", "\uff46"); put("\uff27", "\uff47"); put("\uff28", "\uff48"); put("\uff29", "\uff49"); put("\uff2a", "\uff4a"); |
| put("\uff46", "\uff26"); put("\uff47", "\uff27"); put("\uff48", "\uff28"); put("\uff49", "\uff29"); put("\uff4a", "\uff2a"); |
| put("\uff2b", "\uff4b"); put("\uff2c", "\uff4c"); put("\uff2d", "\uff4d"); put("\uff2e", "\uff4e"); put("\uff2f", "\uff4f"); |
| put("\uff4b", "\uff2b"); put("\uff4c", "\uff2c"); put("\uff4d", "\uff2d"); put("\uff4e", "\uff2e"); put("\uff4f", "\uff2f"); |
| put("\uff30", "\uff50"); put("\uff31", "\uff51"); put("\uff32", "\uff52"); put("\uff33", "\uff53"); put("\uff34", "\uff54"); |
| put("\uff50", "\uff30"); put("\uff51", "\uff31"); put("\uff52", "\uff32"); put("\uff53", "\uff33"); put("\uff54", "\uff34"); |
| put("\uff35", "\uff55"); put("\uff36", "\uff56"); put("\uff37", "\uff57"); put("\uff38", "\uff58"); put("\uff39", "\uff59"); |
| put("\uff55", "\uff35"); put("\uff56", "\uff36"); put("\uff57", "\uff37"); put("\uff58", "\uff38"); put("\uff59", "\uff39"); |
| put("\uff3a", "\uff5a"); |
| put("\uff5a", "\uff3a"); |
| }}; |
| |
| /** Toggle cycle table for half-width alphabet */ |
| private static final String[][] JP_HALF_ALPHABET_CYCLE_TABLE = { |
| {".", "@", "-", "_", "/", ":", "~", "1"}, |
| {"a", "b", "c", "A", "B", "C", "2"}, |
| {"d", "e", "f", "D", "E", "F", "3"}, |
| {"g", "h", "i", "G", "H", "I", "4"}, |
| {"j", "k", "l", "J", "K", "L", "5"}, |
| {"m", "n", "o", "M", "N", "O", "6"}, |
| {"p", "q", "r", "s", "P", "Q", "R", "S", "7"}, |
| {"t", "u", "v", "T", "U", "V", "8"}, |
| {"w", "x", "y", "z", "W", "X", "Y", "Z", "9"}, |
| {"-", "0"}, |
| {",", ".", "?", "!", ";", " "} |
| }; |
| |
| /** Replace table for half-width alphabet */ |
| private static final HashMap<String,String> JP_HALF_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{ |
| put("A", "a"); put("B", "b"); put("C", "c"); put("D", "d"); put("E", "e"); |
| put("a", "A"); put("b", "B"); put("c", "C"); put("d", "D"); put("e", "E"); |
| put("F", "f"); put("G", "g"); put("H", "h"); put("I", "i"); put("J", "j"); |
| put("f", "F"); put("g", "G"); put("h", "H"); put("i", "I"); put("j", "J"); |
| put("K", "k"); put("L", "l"); put("M", "m"); put("N", "n"); put("O", "o"); |
| put("k", "K"); put("l", "L"); put("m", "M"); put("n", "N"); put("o", "O"); |
| put("P", "p"); put("Q", "q"); put("R", "r"); put("S", "s"); put("T", "t"); |
| put("p", "P"); put("q", "Q"); put("r", "R"); put("s", "S"); put("t", "T"); |
| put("U", "u"); put("V", "v"); put("W", "w"); put("X", "x"); put("Y", "y"); |
| put("u", "U"); put("v", "V"); put("w", "W"); put("x", "X"); put("y", "Y"); |
| put("Z", "z"); |
| put("z", "Z"); |
| }}; |
| |
| /** Character table for full-width number */ |
| private static final char[] INSTANT_CHAR_CODE_FULL_NUMBER = |
| "\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19\uff10\uff03\uff0a".toCharArray(); |
| |
| /** Character table for half-width number */ |
| private static final char[] INSTANT_CHAR_CODE_HALF_NUMBER = |
| "1234567890#*".toCharArray(); |
| |
| /** The constant for mFixedKeyMode. It means that input mode is not fixed. */ |
| private static final int INVALID_KEYMODE = -1; |
| |
| /** KeyIndex of "Moji" key on 12 keyboard (depends on the definition of keyboards) */ |
| private static final int KEY_INDEX_CHANGE_MODE_12KEY = 15; |
| |
| /** KeyIndex of "Moji" key on QWERTY keyboard (depends on the definition of keyboards) */ |
| private static final int KEY_INDEX_CHANGE_MODE_QWERTY = 29; |
| |
| /** Type of input mode */ |
| private int mInputType = INPUT_TYPE_TOGGLE; |
| |
| /** Previous input character code */ |
| private int mPrevInputKeyCode = 0; |
| |
| /** |
| * Character table to input when mInputType becomes INPUT_TYPE_INSTANT. |
| * (Either INSTANT_CHAR_CODE_FULL_NUMBER or INSTANT_CHAR_CODE_HALF_NUMBER) |
| */ |
| private char[] mCurrentInstantTable = null; |
| |
| /** Input mode that is not able to be changed. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */ |
| private int[] mLimitedKeyMode = null; |
| |
| /** Input mode that is given the first priority. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */ |
| private int mPreferenceKeyMode = INVALID_KEYMODE; |
| |
| /** The last input type */ |
| private int mLastInputType = 0; |
| |
| /** Auto caps mode */ |
| private boolean mEnableAutoCaps = true; |
| |
| /** PopupResId of "Moji" key (this is used for canceling long-press) */ |
| private int mPopupResId = 0; |
| |
| /** Whether the InputType is null */ |
| private boolean mIsInputTypeNull = false; |
| |
| /** {@code SharedPreferences} for save the keyboard type */ |
| private SharedPreferences.Editor mPrefEditor = null; |
| |
| /** "Moji" key (this is used for canceling long-press) */ |
| private Keyboard.Key mChangeModeKey = null; |
| |
| |
| /** Default constructor */ |
| public DefaultSoftKeyboardJAJP() { |
| mCurrentLanguage = LANG_JA; |
| if (OpenWnn.isXLarge()) { |
| mCurrentKeyboardType = KEYBOARD_QWERTY; |
| } else { |
| mCurrentKeyboardType = KEYBOARD_12KEY; |
| } |
| mShiftOn = KEYBOARD_SHIFT_OFF; |
| mCurrentKeyMode = KEYMODE_JA_FULL_HIRAGANA; |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#createKeyboards */ |
| @Override protected void createKeyboards(OpenWnn parent) { |
| |
| /* Keyboard[# of Languages][portrait/landscape][# of keyboard type][shift off/on][max # of key-modes][noinput/input] */ |
| mKeyboard = new Keyboard[3][2][4][2][8][2]; |
| |
| if (mHardKeyboardHidden) { |
| /* Create the suitable keyboard object */ |
| if (mDisplayMode == DefaultSoftKeyboard.PORTRAIT) { |
| createKeyboardsPortrait(parent); |
| } else { |
| createKeyboardsLandscape(parent); |
| } |
| |
| if (mCurrentKeyboardType == KEYBOARD_12KEY) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); |
| } |
| } else if (mEnableHardware12Keyboard) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); |
| } |
| } |
| |
| /** |
| * Commit the pre-edit string for committing operation that is not explicit |
| * (ex. when a candidate is selected) |
| */ |
| private void commitText() { |
| if (!mNoInput) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.COMMIT_COMPOSING_TEXT)); |
| } |
| } |
| |
| /** |
| * Change input mode |
| * <br> |
| * @param keyMode The type of input mode |
| */ |
| public void changeKeyMode(int keyMode) { |
| int targetMode = filterKeyMode(keyMode); |
| if (targetMode == INVALID_KEYMODE) { |
| return; |
| } |
| |
| commitText(); |
| |
| if (mCapsLock) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, |
| new KeyEvent(KeyEvent.ACTION_UP, |
| KeyEvent.KEYCODE_SHIFT_LEFT))); |
| mCapsLock = false; |
| } |
| mShiftOn = KEYBOARD_SHIFT_OFF; |
| Keyboard kbd = getModeChangeKeyboard(targetMode); |
| mCurrentKeyMode = targetMode; |
| mPrevInputKeyCode = 0; |
| |
| int mode = OpenWnnEvent.Mode.DIRECT; |
| |
| switch (targetMode) { |
| case KEYMODE_JA_FULL_HIRAGANA: |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnEvent.Mode.DEFAULT; |
| break; |
| |
| case KEYMODE_JA_HALF_ALPHABET: |
| if (USE_ENGLISH_PREDICT) { |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnEvent.Mode.NO_LV1_CONV; |
| } else { |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnEvent.Mode.DIRECT; |
| } |
| break; |
| |
| case KEYMODE_JA_FULL_NUMBER: |
| mInputType = INPUT_TYPE_INSTANT; |
| mode = OpenWnnEvent.Mode.DIRECT; |
| mCurrentInstantTable = INSTANT_CHAR_CODE_FULL_NUMBER; |
| break; |
| |
| case KEYMODE_JA_HALF_NUMBER: |
| mInputType = INPUT_TYPE_INSTANT; |
| mode = OpenWnnEvent.Mode.DIRECT; |
| mCurrentInstantTable = INSTANT_CHAR_CODE_HALF_NUMBER; |
| break; |
| |
| case KEYMODE_JA_FULL_KATAKANA: |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnJAJP.ENGINE_MODE_FULL_KATAKANA; |
| break; |
| |
| case KEYMODE_JA_FULL_ALPHABET: |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnEvent.Mode.DIRECT; |
| break; |
| |
| case KEYMODE_JA_HALF_KATAKANA: |
| mInputType = INPUT_TYPE_TOGGLE; |
| mode = OpenWnnJAJP.ENGINE_MODE_HALF_KATAKANA; |
| break; |
| |
| default: |
| break; |
| } |
| |
| setStatusIcon(); |
| changeKeyboard(kbd); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, mode)); |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#initView */ |
| @Override public View initView(OpenWnn parent, int width, int height) { |
| |
| View view = super.initView(parent, width, height); |
| changeKeyboard(mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mCurrentKeyMode][0]); |
| |
| return view; |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#changeKeyboard */ |
| @Override protected boolean changeKeyboard(Keyboard keyboard) { |
| if (keyboard != null) { |
| if (mIsInputTypeNull && mChangeModeKey != null) { |
| mChangeModeKey.popupResId = mPopupResId; |
| } |
| |
| List<Keyboard.Key> keys = keyboard.getKeys(); |
| int keyIndex = (KEY_NUMBER_12KEY < keys.size()) |
| ? KEY_INDEX_CHANGE_MODE_QWERTY : KEY_INDEX_CHANGE_MODE_12KEY; |
| mChangeModeKey = keys.get(keyIndex); |
| |
| if (mIsInputTypeNull && mChangeModeKey != null) { |
| mPopupResId = mChangeModeKey.popupResId; |
| mChangeModeKey.popupResId = 0; |
| } |
| } |
| |
| return super.changeKeyboard(keyboard); |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#changeKeyboardType */ |
| @Override public void changeKeyboardType(int type) { |
| commitText(); |
| Keyboard kbd = getTypeChangeKeyboard(type); |
| if (kbd != null) { |
| mCurrentKeyboardType = type; |
| mPrefEditor.putBoolean("opt_enable_qwerty", type == KEYBOARD_QWERTY); |
| mPrefEditor.commit(); |
| changeKeyboard(kbd); |
| } |
| if (type == KEYBOARD_12KEY) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#onKey */ |
| @Override public void onKey(int primaryCode, int[] keyCodes) { |
| |
| if (mDisableKeyInput) { |
| return; |
| } |
| |
| switch (primaryCode) { |
| case KEYCODE_JP12_TOGGLE_MODE: |
| case KEYCODE_QWERTY_TOGGLE_MODE: |
| if (!mIsInputTypeNull) { |
| nextKeyMode(); |
| } |
| break; |
| |
| case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE: |
| case KEYCODE_JP12_BACKSPACE: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))); |
| break; |
| |
| case DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT: |
| toggleShiftLock(); |
| break; |
| |
| case DefaultSoftKeyboard.KEYCODE_QWERTY_ALT: |
| processAltKey(); |
| break; |
| |
| case KEYCODE_QWERTY_ENTER: |
| case KEYCODE_JP12_ENTER: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER))); |
| break; |
| |
| case KEYCODE_JP12_REVERSE: |
| if (!mNoInput && !mEnableHardware12Keyboard) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.TOGGLE_REVERSE_CHAR, mCurrentCycleTable)); |
| } |
| break; |
| |
| case KEYCODE_QWERTY_KBD: |
| changeKeyboardType(KEYBOARD_12KEY); |
| break; |
| |
| case KEYCODE_JP12_KBD: |
| changeKeyboardType(KEYBOARD_QWERTY); |
| break; |
| |
| case KEYCODE_JP12_EMOJI: |
| case KEYCODE_QWERTY_EMOJI: |
| commitText(); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_SYMBOL)); |
| break; |
| |
| case KEYCODE_JP12_1: |
| case KEYCODE_JP12_2: |
| case KEYCODE_JP12_3: |
| case KEYCODE_JP12_4: |
| case KEYCODE_JP12_5: |
| case KEYCODE_JP12_6: |
| case KEYCODE_JP12_7: |
| case KEYCODE_JP12_8: |
| case KEYCODE_JP12_9: |
| case KEYCODE_JP12_0: |
| case KEYCODE_JP12_SHARP: |
| /* Processing to input by ten key */ |
| if (mInputType == INPUT_TYPE_INSTANT) { |
| /* Send a input character directly if instant input type is selected */ |
| commitText(); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, |
| mCurrentInstantTable[getTableIndex(primaryCode)])); |
| } else { |
| if ((mPrevInputKeyCode != primaryCode)) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.TOUCH_OTHER_KEY)); |
| if ((mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET) |
| && (primaryCode == KEYCODE_JP12_SHARP)) { |
| /* Commit text by symbol character (',' '.') when alphabet input mode is selected */ |
| commitText(); |
| } |
| } |
| |
| /* Convert the key code to the table index and send the toggle event with the table index */ |
| String[][] cycleTable = getCycleTable(); |
| if (cycleTable == null) { |
| Log.e("OpenWnn", "not founds cycle table"); |
| } else { |
| int index = getTableIndex(primaryCode); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.TOGGLE_CHAR, cycleTable[index])); |
| mCurrentCycleTable = cycleTable[index]; |
| } |
| mPrevInputKeyCode = primaryCode; |
| } |
| break; |
| |
| case KEYCODE_JP12_ASTER: |
| if (mInputType == INPUT_TYPE_INSTANT) { |
| commitText(); |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, |
| mCurrentInstantTable[getTableIndex(primaryCode)])); |
| } else { |
| if (!mNoInput) { |
| /* Processing to toggle Dakuten, Handakuten, and capital */ |
| HashMap replaceTable = getReplaceTable(); |
| if (replaceTable == null) { |
| Log.e("OpenWnn", "not founds replace table"); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.REPLACE_CHAR, replaceTable)); |
| mPrevInputKeyCode = primaryCode; |
| } |
| } |
| } |
| break; |
| |
| case KEYCODE_SWITCH_FULL_HIRAGANA: |
| /* Change mode to Full width hiragana */ |
| changeKeyMode(KEYMODE_JA_FULL_HIRAGANA); |
| break; |
| |
| case KEYCODE_SWITCH_FULL_KATAKANA: |
| /* Change mode to Full width katakana */ |
| changeKeyMode(KEYMODE_JA_FULL_KATAKANA); |
| break; |
| |
| case KEYCODE_SWITCH_FULL_ALPHABET: |
| /* Change mode to Full width alphabet */ |
| changeKeyMode(KEYMODE_JA_FULL_ALPHABET); |
| break; |
| |
| case KEYCODE_SWITCH_FULL_NUMBER: |
| /* Change mode to Full width numeric */ |
| changeKeyMode(KEYMODE_JA_FULL_NUMBER); |
| break; |
| |
| case KEYCODE_SWITCH_HALF_KATAKANA: |
| /* Change mode to Half width katakana */ |
| changeKeyMode(KEYMODE_JA_HALF_KATAKANA); |
| break; |
| |
| case KEYCODE_SWITCH_HALF_ALPHABET: |
| /* Change mode to Half width alphabet */ |
| changeKeyMode(KEYMODE_JA_HALF_ALPHABET); |
| break; |
| |
| case KEYCODE_SWITCH_HALF_NUMBER: |
| /* Change mode to Half width numeric */ |
| changeKeyMode(KEYMODE_JA_HALF_NUMBER); |
| break; |
| |
| |
| case KEYCODE_SELECT_CASE: |
| int shifted = (mShiftOn == 0) ? 1 : 0; |
| Keyboard newKeyboard = getShiftChangeKeyboard(shifted); |
| if (newKeyboard != null) { |
| mShiftOn = shifted; |
| changeKeyboard(newKeyboard); |
| } |
| break; |
| |
| case KEYCODE_JP12_SPACE: |
| if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CONVERT)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, ' ')); |
| } |
| break; |
| |
| case KEYCODE_EISU_KANA: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_EISU_KANA)); |
| break; |
| |
| case KEYCODE_JP12_CLOSE: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK))); |
| break; |
| |
| case KEYCODE_JP12_LEFT: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_DPAD_LEFT))); |
| break; |
| |
| case KEYCODE_JP12_RIGHT: |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, |
| new KeyEvent(KeyEvent.ACTION_DOWN, |
| KeyEvent.KEYCODE_DPAD_RIGHT))); |
| break; |
| case KEYCODE_NOP: |
| break; |
| |
| default: |
| if (primaryCode >= 0) { |
| if (mKeyboardView.isShifted()) { |
| primaryCode = Character.toUpperCase(primaryCode); |
| } |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, (char)primaryCode)); |
| } |
| break; |
| } |
| |
| /* update shift key's state */ |
| if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) { |
| setShiftByEditorInfo(); |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#setPreferences */ |
| @Override public void setPreferences(SharedPreferences pref, EditorInfo editor) { |
| mPrefEditor = pref.edit(); |
| boolean isQwerty; |
| if (OpenWnn.isXLarge()) { |
| isQwerty = pref.getBoolean("opt_enable_qwerty", true); |
| } else { |
| isQwerty = pref.getBoolean("opt_enable_qwerty", false); |
| } |
| |
| if (isQwerty && (mCurrentKeyboardType == KEYBOARD_12KEY)) { |
| changeKeyboardType(KEYBOARD_QWERTY); |
| } |
| |
| super.setPreferences(pref, editor); |
| |
| int inputType = editor.inputType; |
| if (mHardKeyboardHidden) { |
| if (inputType == EditorInfo.TYPE_NULL) { |
| if (!mIsInputTypeNull) { |
| mIsInputTypeNull = true; |
| if (mChangeModeKey != null) { |
| mPopupResId = mChangeModeKey.popupResId; |
| mChangeModeKey.popupResId = 0; |
| } |
| } |
| return; |
| } |
| |
| if (mIsInputTypeNull) { |
| mIsInputTypeNull = false; |
| if (mChangeModeKey != null) { |
| mChangeModeKey.popupResId = mPopupResId; |
| } |
| } |
| } |
| |
| mEnableAutoCaps = pref.getBoolean("auto_caps", true); |
| mLimitedKeyMode = null; |
| mPreferenceKeyMode = INVALID_KEYMODE; |
| mNoInput = true; |
| mDisableKeyInput = false; |
| mCapsLock = false; |
| |
| switch (inputType & EditorInfo.TYPE_MASK_CLASS) { |
| |
| case EditorInfo.TYPE_CLASS_NUMBER: |
| case EditorInfo.TYPE_CLASS_DATETIME: |
| mPreferenceKeyMode = KEYMODE_JA_HALF_NUMBER; |
| break; |
| |
| case EditorInfo.TYPE_CLASS_PHONE: |
| if (mHardKeyboardHidden) { |
| mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_PHONE}; |
| } else if (mEnableHardware12Keyboard) { |
| mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_NUMBER}; |
| } else { |
| mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET}; |
| } |
| break; |
| |
| case EditorInfo.TYPE_CLASS_TEXT: |
| switch (inputType & EditorInfo.TYPE_MASK_VARIATION) { |
| |
| case EditorInfo.TYPE_TEXT_VARIATION_PASSWORD: |
| case EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD: |
| mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER}; |
| break; |
| |
| case EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS: |
| case EditorInfo.TYPE_TEXT_VARIATION_URI: |
| mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET; |
| break; |
| |
| default: |
| break; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (inputType != mLastInputType) { |
| setDefaultKeyboard(); |
| mLastInputType = inputType; |
| } |
| |
| setStatusIcon(); |
| setShiftByEditorInfo(); |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#onUpdateState */ |
| @Override public void onUpdateState(OpenWnn parent) { |
| super.onUpdateState(parent); |
| if (!mCapsLock) { |
| setShiftByEditorInfo(); |
| } |
| } |
| |
| /** |
| * Change the keyboard to default |
| */ |
| public void setDefaultKeyboard() { |
| Locale locale = Locale.getDefault(); |
| int keymode = KEYMODE_JA_FULL_HIRAGANA; |
| |
| if (mPreferenceKeyMode != INVALID_KEYMODE) { |
| keymode = mPreferenceKeyMode; |
| } else if (mLimitedKeyMode != null) { |
| keymode = mLimitedKeyMode[0]; |
| } else { |
| if (!locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) { |
| keymode = KEYMODE_JA_HALF_ALPHABET; |
| } |
| } |
| changeKeyMode(keymode); |
| } |
| |
| |
| /** |
| * Change to the next input mode |
| */ |
| public void nextKeyMode() { |
| /* Search the current mode in the toggle table */ |
| boolean found = false; |
| int index; |
| for (index = 0; index < JP_MODE_CYCLE_TABLE.length; index++) { |
| if (JP_MODE_CYCLE_TABLE[index] == mCurrentKeyMode) { |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| /* If the current mode not exists, set the default mode */ |
| setDefaultKeyboard(); |
| } else { |
| /* If the current mode exists, set the next input mode */ |
| int size = JP_MODE_CYCLE_TABLE.length; |
| int keyMode = INVALID_KEYMODE; |
| for (int i = 0; i < size; i++) { |
| index = (++index) % size; |
| |
| keyMode = filterKeyMode(JP_MODE_CYCLE_TABLE[index]); |
| if (keyMode != INVALID_KEYMODE) { |
| break; |
| } |
| } |
| |
| if (keyMode != INVALID_KEYMODE) { |
| changeKeyMode(keyMode); |
| } |
| } |
| } |
| |
| /** |
| * Create the keyboard for portrait mode |
| * <br> |
| * @param parent The context |
| */ |
| private void createKeyboardsPortrait(OpenWnn parent) { |
| Keyboard[][] keyList; |
| if (OpenWnn.isXLarge()) { |
| /* qwerty shift_off (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* qwerty shift_on (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = |
| mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; |
| } else { |
| /* qwerty shift_off (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* qwerty shift_on (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana_shift); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana_shift); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = |
| mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; |
| |
| |
| /* 12-keys shift_off (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp); |
| keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet); |
| keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_full_num); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana); |
| keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana_input); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet); |
| keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_half_num); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana); |
| keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana_input); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* 12-keys shift_on (portrait) */ |
| keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA]; |
| keyList[KEYMODE_JA_FULL_ALPHABET] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET]; |
| keyList[KEYMODE_JA_FULL_NUMBER] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER]; |
| keyList[KEYMODE_JA_FULL_KATAKANA] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA]; |
| keyList[KEYMODE_JA_HALF_ALPHABET] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];; |
| keyList[KEYMODE_JA_HALF_NUMBER] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER]; |
| keyList[KEYMODE_JA_HALF_KATAKANA] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA]; |
| keyList[KEYMODE_JA_HALF_PHONE] |
| = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE]; |
| } |
| } |
| |
| /** |
| * Create the keyboard for landscape mode |
| * <br> |
| * @param parent The context |
| */ |
| private void createKeyboardsLandscape(OpenWnn parent) { |
| Keyboard[][] keyList; |
| if (OpenWnn.isXLarge()) { |
| /* qwerty shift_off (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* qwerty shift_on (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = |
| mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; |
| } else { |
| /* qwerty shift_off (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* qwerty shift_on (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana_shift); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana_shift); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = |
| mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; |
| |
| |
| /* 12-keys shift_off (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp); |
| keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input); |
| keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet); |
| keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input); |
| keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_full_num); |
| keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana); |
| keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana_input); |
| keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet); |
| keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input); |
| keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_half_num); |
| keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana); |
| keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana_input); |
| keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); |
| |
| /* 12-keys shift_on (landscape) */ |
| keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON]; |
| keyList[KEYMODE_JA_FULL_HIRAGANA] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA]; |
| keyList[KEYMODE_JA_FULL_ALPHABET] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET]; |
| keyList[KEYMODE_JA_FULL_NUMBER] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER]; |
| keyList[KEYMODE_JA_FULL_KATAKANA] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA]; |
| keyList[KEYMODE_JA_HALF_ALPHABET] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];; |
| keyList[KEYMODE_JA_HALF_NUMBER] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER]; |
| keyList[KEYMODE_JA_HALF_KATAKANA] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA]; |
| keyList[KEYMODE_JA_HALF_PHONE] |
| = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE]; |
| } |
| } |
| |
| /** |
| * Convert the key code to the index of table |
| * <br> |
| * @param index The key code |
| * @return The index of the toggle table for input |
| */ |
| private int getTableIndex(int keyCode) { |
| int index = |
| (keyCode == KEYCODE_JP12_1) ? 0 : |
| (keyCode == KEYCODE_JP12_2) ? 1 : |
| (keyCode == KEYCODE_JP12_3) ? 2 : |
| (keyCode == KEYCODE_JP12_4) ? 3 : |
| (keyCode == KEYCODE_JP12_5) ? 4 : |
| (keyCode == KEYCODE_JP12_6) ? 5 : |
| (keyCode == KEYCODE_JP12_7) ? 6 : |
| (keyCode == KEYCODE_JP12_8) ? 7 : |
| (keyCode == KEYCODE_JP12_9) ? 8 : |
| (keyCode == KEYCODE_JP12_0) ? 9 : |
| (keyCode == KEYCODE_JP12_SHARP) ? 10 : |
| (keyCode == KEYCODE_JP12_ASTER) ? 11 : |
| 0; |
| |
| return index; |
| } |
| |
| /** |
| * Get the toggle table for input that is appropriate in current mode. |
| * |
| * @return The toggle table for input |
| */ |
| private String[][] getCycleTable() { |
| String[][] cycleTable = null; |
| switch (mCurrentKeyMode) { |
| case KEYMODE_JA_FULL_HIRAGANA: |
| cycleTable = JP_FULL_HIRAGANA_CYCLE_TABLE; |
| break; |
| |
| case KEYMODE_JA_FULL_KATAKANA: |
| cycleTable = JP_FULL_KATAKANA_CYCLE_TABLE; |
| break; |
| |
| case KEYMODE_JA_FULL_ALPHABET: |
| cycleTable = JP_FULL_ALPHABET_CYCLE_TABLE; |
| break; |
| |
| case KEYMODE_JA_FULL_NUMBER: |
| case KEYMODE_JA_HALF_NUMBER: |
| /* Because these modes belong to direct input group, No toggle table exists */ |
| break; |
| |
| case KEYMODE_JA_HALF_ALPHABET: |
| cycleTable = JP_HALF_ALPHABET_CYCLE_TABLE; |
| break; |
| |
| case KEYMODE_JA_HALF_KATAKANA: |
| cycleTable = JP_HALF_KATAKANA_CYCLE_TABLE; |
| break; |
| |
| default: |
| break; |
| } |
| return cycleTable; |
| } |
| |
| /** |
| * Get the replace table that is appropriate in current mode. |
| * |
| * @return The replace table |
| */ |
| private HashMap getReplaceTable() { |
| HashMap hashTable = null; |
| switch (mCurrentKeyMode) { |
| case KEYMODE_JA_FULL_HIRAGANA: |
| hashTable = JP_FULL_HIRAGANA_REPLACE_TABLE; |
| break; |
| case KEYMODE_JA_FULL_KATAKANA: |
| hashTable = JP_FULL_KATAKANA_REPLACE_TABLE; |
| break; |
| |
| case KEYMODE_JA_FULL_ALPHABET: |
| hashTable = JP_FULL_ALPHABET_REPLACE_TABLE; |
| break; |
| |
| case KEYMODE_JA_FULL_NUMBER: |
| case KEYMODE_JA_HALF_NUMBER: |
| /* Because these modes belong to direct input group, No replacing table exists */ |
| break; |
| |
| case KEYMODE_JA_HALF_ALPHABET: |
| hashTable = JP_HALF_ALPHABET_REPLACE_TABLE; |
| break; |
| |
| case KEYMODE_JA_HALF_KATAKANA: |
| hashTable = JP_HALF_KATAKANA_REPLACE_TABLE; |
| break; |
| |
| default: |
| break; |
| } |
| return hashTable; |
| } |
| |
| /** |
| * Set the status icon that is appropriate in current mode |
| */ |
| private void setStatusIcon() { |
| int icon = 0; |
| |
| switch (mCurrentKeyMode) { |
| case KEYMODE_JA_FULL_HIRAGANA: |
| icon = R.drawable.immodeic_hiragana; |
| break; |
| case KEYMODE_JA_FULL_KATAKANA: |
| icon = R.drawable.immodeic_full_kana; |
| break; |
| case KEYMODE_JA_FULL_ALPHABET: |
| icon = R.drawable.immodeic_full_alphabet; |
| break; |
| case KEYMODE_JA_FULL_NUMBER: |
| icon = R.drawable.immodeic_full_number; |
| break; |
| case KEYMODE_JA_HALF_KATAKANA: |
| icon = R.drawable.immodeic_half_kana; |
| break; |
| case KEYMODE_JA_HALF_ALPHABET: |
| icon = R.drawable.immodeic_half_alphabet; |
| break; |
| case KEYMODE_JA_HALF_NUMBER: |
| case KEYMODE_JA_HALF_PHONE: |
| icon = R.drawable.immodeic_half_number; |
| break; |
| default: |
| break; |
| } |
| |
| mWnn.showStatusIcon(icon); |
| } |
| |
| /** |
| * Get the shift key state from the editor. |
| * <br> |
| * @param editor The editor information |
| * @return The state id of the shift key (0:off, 1:on) |
| */ |
| protected int getShiftKeyState(EditorInfo editor) { |
| InputConnection connection = mWnn.getCurrentInputConnection(); |
| if (connection != null) { |
| int caps = connection.getCursorCapsMode(editor.inputType); |
| return (caps == 0) ? 0 : 1; |
| } else { |
| return 0; |
| } |
| } |
| |
| /** |
| * Set the shift key state from {@link EditorInfo}. |
| */ |
| private void setShiftByEditorInfo() { |
| if (mEnableAutoCaps && (mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)) { |
| int shift = getShiftKeyState(mWnn.getCurrentInputEditorInfo()); |
| |
| mShiftOn = shift; |
| changeKeyboard(getShiftChangeKeyboard(shift)); |
| } |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#setHardKeyboardHidden */ |
| @Override public void setHardKeyboardHidden(boolean hidden) { |
| if (mWnn != null) { |
| if (!hidden) { |
| if (mEnableHardware12Keyboard) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); |
| } |
| } |
| |
| if (mHardKeyboardHidden != hidden) { |
| if ((mLimitedKeyMode != null) |
| || (!mEnableHardware12Keyboard |
| && (mCurrentKeyMode != KEYMODE_JA_FULL_HIRAGANA) |
| && (mCurrentKeyMode != KEYMODE_JA_HALF_ALPHABET))) { |
| |
| mLastInputType = EditorInfo.TYPE_NULL; |
| if (mWnn.isInputViewShown()) { |
| setDefaultKeyboard(); |
| } |
| } |
| } |
| } |
| super.setHardKeyboardHidden(hidden); |
| } |
| |
| /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#setHardware12Keyboard */ |
| @Override public void setHardware12Keyboard(boolean type12Key) { |
| if (mWnn != null) { |
| if (mEnableHardware12Keyboard != type12Key) { |
| if (type12Key) { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); |
| } else { |
| mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, |
| OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); |
| } |
| } |
| } |
| super.setHardware12Keyboard(type12Key); |
| } |
| |
| /** |
| * Change the key-mode to the allowed one which is restricted |
| * by the text input field or the type of the keyboard. |
| * @param keyMode The key-mode |
| * @return the key-mode allowed |
| */ |
| private int filterKeyMode(int keyMode) { |
| int targetMode = keyMode; |
| int[] limits = mLimitedKeyMode; |
| |
| if (!mHardKeyboardHidden) { /* for hardware keyboard */ |
| if (!mEnableHardware12Keyboard && (targetMode != KEYMODE_JA_FULL_HIRAGANA) |
| && (targetMode != KEYMODE_JA_HALF_ALPHABET)) { |
| |
| Locale locale = Locale.getDefault(); |
| int keymode = KEYMODE_JA_HALF_ALPHABET; |
| if (locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) { |
| switch (targetMode) { |
| case KEYMODE_JA_FULL_HIRAGANA: |
| case KEYMODE_JA_FULL_KATAKANA: |
| case KEYMODE_JA_HALF_KATAKANA: |
| keymode = KEYMODE_JA_FULL_HIRAGANA; |
| break; |
| default: |
| /* half-alphabet */ |
| break; |
| } |
| } |
| targetMode = keymode; |
| } |
| } |
| |
| /* restrict by the type of the text field */ |
| if (limits != null) { |
| boolean hasAccepted = false; |
| boolean hasRequiredChange = true; |
| int size = limits.length; |
| int nowMode = mCurrentKeyMode; |
| |
| for (int i = 0; i < size; i++) { |
| if (targetMode == limits[i]) { |
| hasAccepted = true; |
| break; |
| } |
| if (nowMode == limits[i]) { |
| hasRequiredChange = false; |
| } |
| } |
| |
| if (!hasAccepted) { |
| if (hasRequiredChange) { |
| targetMode = mLimitedKeyMode[0]; |
| } else { |
| targetMode = INVALID_KEYMODE; |
| } |
| } |
| } |
| |
| return targetMode; |
| } |
| |
| /** |
| * Shows input mode choosing dialog. |
| * |
| * @return boolean |
| */ |
| public boolean showInputModeSwitchDialog() { |
| BaseInputView baseInputView = (BaseInputView)getCurrentView(); |
| AlertDialog.Builder builder = new AlertDialog.Builder(baseInputView.getContext()); |
| builder.setCancelable(true); |
| builder.setNegativeButton(R.string.dialog_button_cancel, null); |
| |
| Resources r = baseInputView.getResources(); |
| CharSequence itemFullHirakana = r.getString(R.string.ti_input_mode_full_hirakana_title_txt); |
| CharSequence itemFullKatakana = r.getString(R.string.ti_input_mode_full_katakana_title_txt); |
| CharSequence itemHalfKatakana = r.getString(R.string.ti_input_mode_half_katakana_title_txt); |
| CharSequence itemFullAlphabet = r.getString(R.string.ti_input_mode_full_alphabet_title_txt); |
| CharSequence itemHalfAlphabet = r.getString(R.string.ti_input_mode_half_alphabet_title_txt); |
| CharSequence itemFullNumber = r.getString(R.string.ti_input_mode_full_number_title_txt); |
| CharSequence itemHalfNumber = r.getString(R.string.ti_input_mode_half_number_title_txt); |
| final CharSequence[] itemTitles; |
| final int[] itemValues; |
| if (OpenWnn.isXLarge()) { |
| itemTitles = new CharSequence[] {itemFullHirakana, itemHalfAlphabet, |
| itemFullNumber, itemHalfNumber}; |
| itemValues = new int[] {KEYMODE_JA_FULL_HIRAGANA, KEYMODE_JA_HALF_ALPHABET, |
| KEYMODE_JA_FULL_NUMBER, KEYMODE_JA_HALF_NUMBER}; |
| } else { |
| itemTitles = new CharSequence[] {itemFullHirakana, itemFullKatakana, itemHalfKatakana, |
| itemFullAlphabet, itemHalfAlphabet, itemFullNumber, |
| itemHalfNumber}; |
| itemValues = new int[] {KEYMODE_JA_FULL_HIRAGANA, KEYMODE_JA_FULL_KATAKANA, KEYMODE_JA_HALF_KATAKANA, |
| KEYMODE_JA_FULL_ALPHABET, KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_FULL_NUMBER, KEYMODE_JA_HALF_NUMBER}; |
| } |
| |
| builder.setSingleChoiceItems(itemTitles, findIndexOfValue(itemValues, |
| mCurrentKeyMode), new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface inputModeSwitchDialog, int position) { |
| switch(position){ |
| case 0: |
| changeKeyMode(itemValues[0]); |
| break; |
| |
| case 1: |
| changeKeyMode(itemValues[1]); |
| break; |
| |
| case 2: |
| changeKeyMode(itemValues[2]); |
| break; |
| |
| case 3: |
| changeKeyMode(itemValues[3]); |
| break; |
| |
| case 4: |
| changeKeyMode(itemValues[4]); |
| break; |
| |
| case 5: |
| changeKeyMode(itemValues[5]); |
| break; |
| |
| case 6: |
| changeKeyMode(itemValues[6]); |
| break; |
| |
| default: |
| break; |
| } |
| inputModeSwitchDialog.dismiss(); |
| } |
| }); |
| |
| builder.setTitle(r.getString(R.string.ti_long_press_dialog_input_mode_txt)); |
| baseInputView.showDialog(builder); |
| return true; |
| } |
| |
| /** |
| * Finds the index of a value in a int[]. |
| * |
| * @param value the int[] to search in, |
| * @param mode the value need to find index, |
| * @return the index of the value. |
| */ |
| private int findIndexOfValue(int[] value, int mode) { |
| for (int i = 0; i < value.length; i++) { |
| if (value[i] == mode) { |
| return i; |
| } |
| } |
| return -1; |
| } |
| } |