DefaultSoftKeyboardJAJP.java revision 7b3b414976b6b3d6d85459de79e843d5ab35ed06
1/* 2 * Copyright (C) 2008,2009 OMRON SOFTWARE Co., Ltd. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package jp.co.omronsoft.openwnn.JAJP; 18 19import jp.co.omronsoft.openwnn.*; 20import android.view.KeyEvent; 21import android.view.inputmethod.EditorInfo; 22import android.inputmethodservice.Keyboard; 23import android.inputmethodservice.Keyboard.Key; 24import android.inputmethodservice.KeyboardView; 25import android.widget.Toast; 26import android.provider.Settings; 27import android.util.Log; 28import android.view.View; 29import android.content.Context; 30import android.content.SharedPreferences; 31 32import java.util.HashMap; 33import java.util.List; 34import java.util.Locale; 35 36/** 37 * Software Keyboard for OpenWnn Japanese 38 * 39 * @author Copyright (C) 2009, OMRON SOFTWARE CO., LTD. All Rights Reserved. 40 */ 41public class DefaultSoftKeyboardJAJP extends DefaultSoftKeyboard { 42 /** Enable English word prediction on half-width alphabet mode */ 43 private static final boolean USE_ENGLISH_PREDICT = true; 44 45 /** Key code for switching to full-width HIRAGANA mode */ 46 private static final int KEYCODE_SWITCH_FULL_HIRAGANA = -301; 47 48 /** Key code for switching to full-width KATAKANA mode */ 49 private static final int KEYCODE_SWITCH_FULL_KATAKANA = -302; 50 51 /** Key code for switching to full-width alphabet mode */ 52 private static final int KEYCODE_SWITCH_FULL_ALPHABET = -303; 53 54 /** Key code for switching to full-width number mode */ 55 private static final int KEYCODE_SWITCH_FULL_NUMBER = -304; 56 57 /** Key code for switching to half-width KATAKANA mode */ 58 private static final int KEYCODE_SWITCH_HALF_KATAKANA = -306; 59 60 /** Key code for switching to half-width alphabet mode */ 61 private static final int KEYCODE_SWITCH_HALF_ALPHABET = -307; 62 63 /** Key code for switching to half-width number mode */ 64 private static final int KEYCODE_SWITCH_HALF_NUMBER = -308; 65 66 /** Key code for case toggle key */ 67 private static final int KEYCODE_SELECT_CASE = -309; 68 69 /** Key code for EISU-KANA conversion */ 70 private static final int KEYCODE_EISU_KANA = -305; 71 72 /** Key code for NOP (no-operation) */ 73 private static final int KEYCODE_NOP = -310; 74 75 76 /** Input mode toggle cycle table */ 77 private static final int[] JP_MODE_CYCLE_TABLE = { 78 KEYMODE_JA_FULL_HIRAGANA, KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER 79 }; 80 81 /** Definition for {@code mInputType} (toggle) */ 82 private static final int INPUT_TYPE_TOGGLE = 1; 83 84 /** Definition for {@code mInputType} (commit instantly) */ 85 private static final int INPUT_TYPE_INSTANT = 2; 86 87 /** Toggle cycle table for full-width HIRAGANA */ 88 private static final String[][] JP_FULL_HIRAGANA_CYCLE_TABLE = { 89 {"\u3042", "\u3044", "\u3046", "\u3048", "\u304a", "\u3041", "\u3043", "\u3045", "\u3047", "\u3049"}, 90 {"\u304b", "\u304d", "\u304f", "\u3051", "\u3053"}, 91 {"\u3055", "\u3057", "\u3059", "\u305b", "\u305d"}, 92 {"\u305f", "\u3061", "\u3064", "\u3066", "\u3068", "\u3063"}, 93 {"\u306a", "\u306b", "\u306c", "\u306d", "\u306e"}, 94 {"\u306f", "\u3072", "\u3075", "\u3078", "\u307b"}, 95 {"\u307e", "\u307f", "\u3080", "\u3081", "\u3082"}, 96 {"\u3084", "\u3086", "\u3088", "\u3083", "\u3085", "\u3087"}, 97 {"\u3089", "\u308a", "\u308b", "\u308c", "\u308d"}, 98 {"\u308f", "\u3092", "\u3093", "\u308e", "\u30fc"}, 99 {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"}, 100 }; 101 102 /** Replace table for full-width HIRAGANA */ 103 private static final HashMap<String, String> JP_FULL_HIRAGANA_REPLACE_TABLE = new HashMap<String, String>() {{ 104 put("\u3042", "\u3041"); put("\u3044", "\u3043"); put("\u3046", "\u3045"); put("\u3048", "\u3047"); put("\u304a", "\u3049"); 105 put("\u3041", "\u3042"); put("\u3043", "\u3044"); put("\u3045", "\u30f4"); put("\u3047", "\u3048"); put("\u3049", "\u304a"); 106 put("\u304b", "\u304c"); put("\u304d", "\u304e"); put("\u304f", "\u3050"); put("\u3051", "\u3052"); put("\u3053", "\u3054"); 107 put("\u304c", "\u304b"); put("\u304e", "\u304d"); put("\u3050", "\u304f"); put("\u3052", "\u3051"); put("\u3054", "\u3053"); 108 put("\u3055", "\u3056"); put("\u3057", "\u3058"); put("\u3059", "\u305a"); put("\u305b", "\u305c"); put("\u305d", "\u305e"); 109 put("\u3056", "\u3055"); put("\u3058", "\u3057"); put("\u305a", "\u3059"); put("\u305c", "\u305b"); put("\u305e", "\u305d"); 110 put("\u305f", "\u3060"); put("\u3061", "\u3062"); put("\u3064", "\u3063"); put("\u3066", "\u3067"); put("\u3068", "\u3069"); 111 put("\u3060", "\u305f"); put("\u3062", "\u3061"); put("\u3063", "\u3065"); put("\u3067", "\u3066"); put("\u3069", "\u3068"); 112 put("\u3065", "\u3064"); put("\u30f4", "\u3046"); 113 put("\u306f", "\u3070"); put("\u3072", "\u3073"); put("\u3075", "\u3076"); put("\u3078", "\u3079"); put("\u307b", "\u307c"); 114 put("\u3070", "\u3071"); put("\u3073", "\u3074"); put("\u3076", "\u3077"); put("\u3079", "\u307a"); put("\u307c", "\u307d"); 115 put("\u3071", "\u306f"); put("\u3074", "\u3072"); put("\u3077", "\u3075"); put("\u307a", "\u3078"); put("\u307d", "\u307b"); 116 put("\u3084", "\u3083"); put("\u3086", "\u3085"); put("\u3088", "\u3087"); 117 put("\u3083", "\u3084"); put("\u3085", "\u3086"); put("\u3087", "\u3088"); 118 put("\u308f", "\u308e"); 119 put("\u308e", "\u308f"); 120 put("\u309b", "\u309c"); 121 put("\u309c", "\u309b"); 122 }}; 123 124 /** Toggle cycle table for full-width KATAKANA */ 125 private static final String[][] JP_FULL_KATAKANA_CYCLE_TABLE = { 126 {"\u30a2", "\u30a4", "\u30a6", "\u30a8", "\u30aa", "\u30a1", "\u30a3", 127 "\u30a5", "\u30a7", "\u30a9"}, 128 {"\u30ab", "\u30ad", "\u30af", "\u30b1", "\u30b3"}, 129 {"\u30b5", "\u30b7", "\u30b9", "\u30bb", "\u30bd"}, 130 {"\u30bf", "\u30c1", "\u30c4", "\u30c6", "\u30c8", "\u30c3"}, 131 {"\u30ca", "\u30cb", "\u30cc", "\u30cd", "\u30ce"}, 132 {"\u30cf", "\u30d2", "\u30d5", "\u30d8", "\u30db"}, 133 {"\u30de", "\u30df", "\u30e0", "\u30e1", "\u30e2"}, 134 {"\u30e4", "\u30e6", "\u30e8", "\u30e3", "\u30e5", "\u30e7"}, 135 {"\u30e9", "\u30ea", "\u30eb", "\u30ec", "\u30ed"}, 136 {"\u30ef", "\u30f2", "\u30f3", "\u30ee", "\u30fc"}, 137 {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"} 138 }; 139 140 /** Replace table for full-width KATAKANA */ 141 private static final HashMap<String,String> JP_FULL_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{ 142 put("\u30a2", "\u30a1"); put("\u30a4", "\u30a3"); put("\u30a6", "\u30a5"); put("\u30a8", "\u30a7"); put("\u30aa", "\u30a9"); 143 put("\u30a1", "\u30a2"); put("\u30a3", "\u30a4"); put("\u30a5", "\u30f4"); put("\u30a7", "\u30a8"); put("\u30a9", "\u30aa"); 144 put("\u30ab", "\u30ac"); put("\u30ad", "\u30ae"); put("\u30af", "\u30b0"); put("\u30b1", "\u30b2"); put("\u30b3", "\u30b4"); 145 put("\u30ac", "\u30ab"); put("\u30ae", "\u30ad"); put("\u30b0", "\u30af"); put("\u30b2", "\u30b1"); put("\u30b4", "\u30b3"); 146 put("\u30b5", "\u30b6"); put("\u30b7", "\u30b8"); put("\u30b9", "\u30ba"); put("\u30bb", "\u30bc"); put("\u30bd", "\u30be"); 147 put("\u30b6", "\u30b5"); put("\u30b8", "\u30b7"); put("\u30ba", "\u30b9"); put("\u30bc", "\u30bb"); put("\u30be", "\u30bd"); 148 put("\u30bf", "\u30c0"); put("\u30c1", "\u30c2"); put("\u30c4", "\u30c3"); put("\u30c6", "\u30c7"); put("\u30c8", "\u30c9"); 149 put("\u30c0", "\u30bf"); put("\u30c2", "\u30c1"); put("\u30c3", "\u30c5"); put("\u30c7", "\u30c6"); put("\u30c9", "\u30c8"); 150 put("\u30c5", "\u30c4"); put("\u30f4", "\u30a6"); 151 put("\u30cf", "\u30d0"); put("\u30d2", "\u30d3"); put("\u30d5", "\u30d6"); put("\u30d8", "\u30d9"); put("\u30db", "\u30dc"); 152 put("\u30d0", "\u30d1"); put("\u30d3", "\u30d4"); put("\u30d6", "\u30d7"); put("\u30d9", "\u30da"); put("\u30dc", "\u30dd"); 153 put("\u30d1", "\u30cf"); put("\u30d4", "\u30d2"); put("\u30d7", "\u30d5"); put("\u30da", "\u30d8"); put("\u30dd", "\u30db"); 154 put("\u30e4", "\u30e3"); put("\u30e6", "\u30e5"); put("\u30e8", "\u30e7"); 155 put("\u30e3", "\u30e4"); put("\u30e5", "\u30e6"); put("\u30e7", "\u30e8"); 156 put("\u30ef", "\u30ee"); 157 put("\u30ee", "\u30ef"); 158 }}; 159 160 /** Toggle cycle table for half-width KATAKANA */ 161 private static final String[][] JP_HALF_KATAKANA_CYCLE_TABLE = { 162 {"\uff71", "\uff72", "\uff73", "\uff74", "\uff75", "\uff67", "\uff68", "\uff69", "\uff6a", "\uff6b"}, 163 {"\uff76", "\uff77", "\uff78", "\uff79", "\uff7a"}, 164 {"\uff7b", "\uff7c", "\uff7d", "\uff7e", "\uff7f"}, 165 {"\uff80", "\uff81", "\uff82", "\uff83", "\uff84", "\uff6f"}, 166 {"\uff85", "\uff86", "\uff87", "\uff88", "\uff89"}, 167 {"\uff8a", "\uff8b", "\uff8c", "\uff8d", "\uff8e"}, 168 {"\uff8f", "\uff90", "\uff91", "\uff92", "\uff93"}, 169 {"\uff94", "\uff95", "\uff96", "\uff6c", "\uff6d", "\uff6e"}, 170 {"\uff97", "\uff98", "\uff99", "\uff9a", "\uff9b"}, 171 {"\uff9c", "\uff66", "\uff9d", "\uff70"}, 172 {"\uff64", "\uff61", "?", "!", "\uff65", " "}, 173 }; 174 175 /** Replace table for half-width KATAKANA */ 176 private static final HashMap<String,String> JP_HALF_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{ 177 put("\uff71", "\uff67"); put("\uff72", "\uff68"); put("\uff73", "\uff69"); put("\uff74", "\uff6a"); put("\uff75", "\uff6b"); 178 put("\uff67", "\uff71"); put("\uff68", "\uff72"); put("\uff69", "\uff73\uff9e"); put("\uff6a", "\uff74"); put("\uff6b", "\uff75"); 179 put("\uff76", "\uff76\uff9e"); put("\uff77", "\uff77\uff9e"); put("\uff78", "\uff78\uff9e"); put("\uff79", "\uff79\uff9e"); put("\uff7a", "\uff7a\uff9e"); 180 put("\uff76\uff9e", "\uff76"); put("\uff77\uff9e", "\uff77"); put("\uff78\uff9e", "\uff78"); put("\uff79\uff9e", "\uff79"); put("\uff7a\uff9e", "\uff7a"); 181 put("\uff7b", "\uff7b\uff9e"); put("\uff7c", "\uff7c\uff9e"); put("\uff7d", "\uff7d\uff9e"); put("\uff7e", "\uff7e\uff9e"); put("\uff7f", "\uff7f\uff9e"); 182 put("\uff7b\uff9e", "\uff7b"); put("\uff7c\uff9e", "\uff7c"); put("\uff7d\uff9e", "\uff7d"); put("\uff7e\uff9e", "\uff7e"); put("\uff7f\uff9e", "\uff7f"); 183 put("\uff80", "\uff80\uff9e"); put("\uff81", "\uff81\uff9e"); put("\uff82", "\uff6f"); put("\uff83", "\uff83\uff9e"); put("\uff84", "\uff84\uff9e"); 184 put("\uff80\uff9e", "\uff80"); put("\uff81\uff9e", "\uff81"); put("\uff6f", "\uff82\uff9e"); put("\uff83\uff9e", "\uff83"); put("\uff84\uff9e", "\uff84"); 185 put("\uff82\uff9e", "\uff82"); 186 put("\uff8a", "\uff8a\uff9e"); put("\uff8b", "\uff8b\uff9e"); put("\uff8c", "\uff8c\uff9e"); put("\uff8d", "\uff8d\uff9e"); put("\uff8e", "\uff8e\uff9e"); 187 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"); 188 put("\uff8a\uff9f", "\uff8a"); put("\uff8b\uff9f", "\uff8b"); put("\uff8c\uff9f", "\uff8c"); put("\uff8d\uff9f", "\uff8d"); put("\uff8e\uff9f", "\uff8e"); 189 put("\uff94", "\uff6c"); put("\uff95", "\uff6d"); put("\uff96", "\uff6e"); 190 put("\uff6c", "\uff94"); put("\uff6d", "\uff95"); put("\uff6e", "\uff96"); 191 put("\uff9c", "\uff9c"); put("\uff73\uff9e", "\uff73"); 192 }}; 193 194 /** Toggle cycle table for full-width alphabet */ 195 private static final String[][] JP_FULL_ALPHABET_CYCLE_TABLE = { 196 {"\uff0e", "\uff20", "\uff0d", "\uff3f", "\uff0f", "\uff1a", "\uff5e", "\uff11"}, 197 {"\uff41", "\uff42", "\uff43", "\uff21", "\uff22", "\uff23", "\uff12"}, 198 {"\uff44", "\uff45", "\uff46", "\uff24", "\uff25", "\uff26", "\uff13"}, 199 {"\uff47", "\uff48", "\uff49", "\uff27", "\uff28", "\uff29", "\uff14"}, 200 {"\uff4a", "\uff4b", "\uff4c", "\uff2a", "\uff2b", "\uff2c", "\uff15"}, 201 {"\uff4d", "\uff4e", "\uff4f", "\uff2d", "\uff2e", "\uff2f", "\uff16"}, 202 {"\uff50", "\uff51", "\uff52", "\uff53", "\uff30", "\uff31", "\uff32", "\uff33", "\uff17"}, 203 {"\uff54", "\uff55", "\uff56", "\uff34", "\uff35", "\uff36", "\uff18"}, 204 {"\uff57", "\uff58", "\uff59", "\uff5a", "\uff37", "\uff38", "\uff39", "\uff3a", "\uff19"}, 205 {"\uff0d", "\uff10"}, 206 {"\uff0c", "\uff0e", "\uff1f", "\uff01", "\u30fb", "\u3000"} 207 }; 208 209 /** Replace table for full-width alphabet */ 210 private static final HashMap<String,String> JP_FULL_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{ 211 put("\uff21", "\uff41"); put("\uff22", "\uff42"); put("\uff23", "\uff43"); put("\uff24", "\uff44"); put("\uff25", "\uff45"); 212 put("\uff41", "\uff21"); put("\uff42", "\uff22"); put("\uff43", "\uff23"); put("\uff44", "\uff24"); put("\uff45", "\uff25"); 213 put("\uff26", "\uff46"); put("\uff27", "\uff47"); put("\uff28", "\uff48"); put("\uff29", "\uff49"); put("\uff2a", "\uff4a"); 214 put("\uff46", "\uff26"); put("\uff47", "\uff27"); put("\uff48", "\uff28"); put("\uff49", "\uff29"); put("\uff4a", "\uff2a"); 215 put("\uff2b", "\uff4b"); put("\uff2c", "\uff4c"); put("\uff2d", "\uff4d"); put("\uff2e", "\uff4e"); put("\uff2f", "\uff4f"); 216 put("\uff4b", "\uff2b"); put("\uff4c", "\uff2c"); put("\uff4d", "\uff2d"); put("\uff4e", "\uff2e"); put("\uff4f", "\uff2f"); 217 put("\uff30", "\uff50"); put("\uff31", "\uff51"); put("\uff32", "\uff52"); put("\uff33", "\uff53"); put("\uff34", "\uff54"); 218 put("\uff50", "\uff30"); put("\uff51", "\uff31"); put("\uff52", "\uff32"); put("\uff53", "\uff33"); put("\uff54", "\uff34"); 219 put("\uff35", "\uff55"); put("\uff36", "\uff56"); put("\uff37", "\uff57"); put("\uff38", "\uff58"); put("\uff39", "\uff59"); 220 put("\uff55", "\uff35"); put("\uff56", "\uff36"); put("\uff57", "\uff37"); put("\uff58", "\uff38"); put("\uff59", "\uff39"); 221 put("\uff3a", "\uff5a"); 222 put("\uff5a", "\uff3a"); 223 }}; 224 225 /** Toggle cycle table for half-width alphabet */ 226 private static final String[][] JP_HALF_ALPHABET_CYCLE_TABLE = { 227 {".", "@", "-", "_", "/", ":", "~", "1"}, 228 {"a", "b", "c", "A", "B", "C", "2"}, 229 {"d", "e", "f", "D", "E", "F", "3"}, 230 {"g", "h", "i", "G", "H", "I", "4"}, 231 {"j", "k", "l", "J", "K", "L", "5"}, 232 {"m", "n", "o", "M", "N", "O", "6"}, 233 {"p", "q", "r", "s", "P", "Q", "R", "S", "7"}, 234 {"t", "u", "v", "T", "U", "V", "8"}, 235 {"w", "x", "y", "z", "W", "X", "Y", "Z", "9"}, 236 {"-", "0"}, 237 {",", ".", "?", "!", ";", " "} 238 }; 239 240 /** Replace table for half-width alphabet */ 241 private static final HashMap<String,String> JP_HALF_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{ 242 put("A", "a"); put("B", "b"); put("C", "c"); put("D", "d"); put("E", "e"); 243 put("a", "A"); put("b", "B"); put("c", "C"); put("d", "D"); put("e", "E"); 244 put("F", "f"); put("G", "g"); put("H", "h"); put("I", "i"); put("J", "j"); 245 put("f", "F"); put("g", "G"); put("h", "H"); put("i", "I"); put("j", "J"); 246 put("K", "k"); put("L", "l"); put("M", "m"); put("N", "n"); put("O", "o"); 247 put("k", "K"); put("l", "L"); put("m", "M"); put("n", "N"); put("o", "O"); 248 put("P", "p"); put("Q", "q"); put("R", "r"); put("S", "s"); put("T", "t"); 249 put("p", "P"); put("q", "Q"); put("r", "R"); put("s", "S"); put("t", "T"); 250 put("U", "u"); put("V", "v"); put("W", "w"); put("X", "x"); put("Y", "y"); 251 put("u", "U"); put("v", "V"); put("w", "W"); put("x", "X"); put("y", "Y"); 252 put("Z", "z"); 253 put("z", "Z"); 254 }}; 255 256 /** Character table for full-width number */ 257 private static final char[] INSTANT_CHAR_CODE_FULL_NUMBER = 258 "\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19\uff10\uff03\uff0a".toCharArray(); 259 260 /** Character table for half-width number */ 261 private static final char[] INSTANT_CHAR_CODE_HALF_NUMBER = 262 "1234567890#*".toCharArray(); 263 264 /** The constant for mFixedKeyMode. It means that input mode is not fixed. */ 265 private static final int INVALID_KEYMODE = -1; 266 267 /** Type of input mode */ 268 private int mInputType = INPUT_TYPE_TOGGLE; 269 270 /** Previous input character code */ 271 private int mPrevInputKeyCode = 0; 272 273 /** 274 * Character table to input when mInputType becomes INPUT_TYPE_INSTANT. 275 * (Either INSTANT_CHAR_CODE_FULL_NUMBER or INSTANT_CHAR_CODE_HALF_NUMBER) 276 */ 277 private char[] mCurrentInstantTable = null; 278 279 /** Input mode that is not able to be changed. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */ 280 private int mFixedKeyMode = INVALID_KEYMODE; 281 282 /** Input mode that is given the first priority. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */ 283 private int mPreferenceKeyMode = INVALID_KEYMODE; 284 285 /** The last input type */ 286 private int mLastInputType = 0; 287 288 /** Auto caps mode */ 289 private boolean mEnableAutoCaps = true; 290 291 292 /** Default constructor */ 293 public DefaultSoftKeyboardJAJP() { 294 mCurrentLanguage = LANG_JA; 295 mCurrentKeyboardType = KEYBOARD_12KEY; 296 mShiftOn = KEYBOARD_SHIFT_OFF; 297 mCurrentKeyMode = KEYMODE_JA_FULL_HIRAGANA; 298 } 299 300 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#createKeyboards */ 301 @Override protected void createKeyboards(OpenWnn parent) { 302 303 /* Keyboard[# of Languages][portrait/landscape][# of keyboard type][shift off/on][max # of key-modes][noinput/input] */ 304 mKeyboard = new Keyboard[3][2][4][2][8][2]; 305 306 if (mHardKeyboardHidden) { 307 if (mDisplayMode == DefaultSoftKeyboard.PORTRAIT) { 308 createKeyboardsPortrait(parent); 309 } else { 310 createKeyboardsLandscape(parent); 311 } 312 313 if (mCurrentKeyboardType == KEYBOARD_12KEY) { 314 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, 315 OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); 316 } else { 317 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, 318 OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); 319 } 320 } else { 321 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, 322 OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); 323 } 324 } 325 326 /** 327 * Commit the pre-edit string for committing operation that is not explicit (ex. when a candidate is selected) 328 */ 329 private void commitText() { 330 if (!mNoInput) { 331 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.COMMIT_COMPOSING_TEXT)); 332 } 333 } 334 335 /** 336 * Change input mode 337 * <br> 338 * @param keyMode The type of input mode 339 */ 340 public void changeKeyMode(int keyMode) { 341 int targetMode = keyMode; 342 commitText(); 343 344 if (mCapsLock) { 345 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, 346 new KeyEvent(KeyEvent.ACTION_UP, 347 KeyEvent.KEYCODE_SHIFT_LEFT))); 348 mCapsLock = false; 349 } 350 mShiftOn = KEYBOARD_SHIFT_OFF; 351 352 if (mFixedKeyMode != INVALID_KEYMODE) { 353 targetMode = mFixedKeyMode; 354 } 355 356 if (!mHardKeyboardHidden) { 357 if ((targetMode != KEYMODE_JA_FULL_HIRAGANA) 358 && (targetMode != KEYMODE_JA_HALF_ALPHABET)) { 359 360 Locale locale = Locale.getDefault(); 361 int keymode = KEYMODE_JA_HALF_ALPHABET; 362 if (locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) { 363 switch (targetMode) { 364 case KEYMODE_JA_FULL_HIRAGANA: 365 case KEYMODE_JA_FULL_KATAKANA: 366 case KEYMODE_JA_HALF_KATAKANA: 367 keymode = KEYMODE_JA_FULL_HIRAGANA; 368 break; 369 default: 370 break; 371 } 372 } 373 targetMode = keymode; 374 } 375 } 376 Keyboard kbd = getModeChangeKeyboard(targetMode); 377 mCurrentKeyMode = targetMode; 378 mPrevInputKeyCode = 0; 379 380 int mode = OpenWnnEvent.Mode.DIRECT; 381 382 switch (targetMode) { 383 case KEYMODE_JA_FULL_HIRAGANA: 384 mInputType = INPUT_TYPE_TOGGLE; 385 mode = OpenWnnEvent.Mode.DEFAULT; 386 break; 387 388 case KEYMODE_JA_HALF_ALPHABET: 389 if (USE_ENGLISH_PREDICT) { 390 mInputType = INPUT_TYPE_TOGGLE; 391 mode = OpenWnnEvent.Mode.NO_LV1_CONV; 392 } else { 393 mInputType = INPUT_TYPE_TOGGLE; 394 mode = OpenWnnEvent.Mode.DIRECT; 395 } 396 break; 397 398 case KEYMODE_JA_FULL_NUMBER: 399 mInputType = INPUT_TYPE_INSTANT; 400 mode = OpenWnnEvent.Mode.DIRECT; 401 mCurrentInstantTable = INSTANT_CHAR_CODE_FULL_NUMBER; 402 break; 403 404 case KEYMODE_JA_HALF_NUMBER: 405 mInputType = INPUT_TYPE_INSTANT; 406 mode = OpenWnnEvent.Mode.DIRECT; 407 mCurrentInstantTable = INSTANT_CHAR_CODE_HALF_NUMBER; 408 break; 409 410 case KEYMODE_JA_FULL_KATAKANA: 411 mInputType = INPUT_TYPE_TOGGLE; 412 mode = OpenWnnJAJP.ENGINE_MODE_FULL_KATAKANA; 413 break; 414 415 case KEYMODE_JA_FULL_ALPHABET: 416 mInputType = INPUT_TYPE_TOGGLE; 417 mode = OpenWnnEvent.Mode.DIRECT; 418 break; 419 420 case KEYMODE_JA_HALF_KATAKANA: 421 mInputType = INPUT_TYPE_TOGGLE; 422 mode = OpenWnnJAJP.ENGINE_MODE_HALF_KATAKANA; 423 break; 424 425 default: 426 break; 427 } 428 429 setStatusIcon(); 430 changeKeyboard(kbd); 431 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, mode)); 432 } 433 434 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#initView */ 435 @Override public View initView(OpenWnn parent, int width, int height) { 436 437 View view = super.initView(parent, width, height); 438 changeKeyboard(mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mCurrentKeyMode][0]); 439 440 return view; 441 } 442 443 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#changeKeyboardType */ 444 @Override public void changeKeyboardType(int type) { 445 commitText(); 446 Keyboard kbd = getTypeChangeKeyboard(type); 447 if (kbd != null) { 448 mCurrentKeyboardType = type; 449 changeKeyboard(kbd); 450 } 451 if (type == KEYBOARD_12KEY) { 452 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY)); 453 } else { 454 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); 455 } 456 } 457 458 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#onKey */ 459 @Override public void onKey(int primaryCode, int[] keyCodes) { 460 461 switch (primaryCode) { 462 case KEYCODE_JP12_TOGGLE_MODE: 463 case KEYCODE_QWERTY_TOGGLE_MODE: 464 nextKeyMode(); 465 break; 466 467 case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE: 468 case KEYCODE_JP12_BACKSPACE: 469 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, 470 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))); 471 break; 472 473 case DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT: 474 toggleShiftLock(); 475 break; 476 477 case DefaultSoftKeyboard.KEYCODE_QWERTY_ALT: 478 processAltKey(); 479 break; 480 481 case KEYCODE_QWERTY_ENTER: 482 case KEYCODE_JP12_ENTER: 483 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, 484 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER))); 485 break; 486 487 case KEYCODE_JP12_REVERSE: 488 if (!mNoInput) { 489 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.TOGGLE_REVERSE_CHAR, mCurrentCycleTable)); 490 } 491 break; 492 493 case KEYCODE_QWERTY_KBD: 494 changeKeyboardType(KEYBOARD_12KEY); 495 break; 496 497 case KEYCODE_JP12_KBD: 498 changeKeyboardType(KEYBOARD_QWERTY); 499 break; 500 501 case KEYCODE_JP12_EMOJI: 502 case KEYCODE_QWERTY_EMOJI: 503 commitText(); 504 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_SYMBOL)); 505 break; 506 507 case KEYCODE_JP12_1: 508 case KEYCODE_JP12_2: 509 case KEYCODE_JP12_3: 510 case KEYCODE_JP12_4: 511 case KEYCODE_JP12_5: 512 case KEYCODE_JP12_6: 513 case KEYCODE_JP12_7: 514 case KEYCODE_JP12_8: 515 case KEYCODE_JP12_9: 516 case KEYCODE_JP12_0: 517 case KEYCODE_JP12_SHARP: 518 if (mInputType == INPUT_TYPE_INSTANT) { 519 commitText(); 520 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, 521 mCurrentInstantTable[getTableIndex(primaryCode)])); 522 } else { 523 if ((mPrevInputKeyCode != primaryCode)) { 524 if ((mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET) 525 && (primaryCode == KEYCODE_JP12_SHARP)) { 526 commitText(); 527 } 528 } 529 530 String[][] cycleTable = getCycleTable(); 531 if (cycleTable == null) { 532 Log.e("OpenWnn", "not founds cycle table"); 533 } else { 534 int index = getTableIndex(primaryCode); 535 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.TOGGLE_CHAR, cycleTable[index])); 536 mCurrentCycleTable = cycleTable[index]; 537 } 538 mPrevInputKeyCode = primaryCode; 539 } 540 break; 541 542 case KEYCODE_JP12_ASTER: 543 if (mInputType == INPUT_TYPE_INSTANT) { 544 commitText(); 545 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, 546 mCurrentInstantTable[getTableIndex(primaryCode)])); 547 } else { 548 if (!mNoInput) { 549 HashMap replaceTable = getReplaceTable(); 550 if (replaceTable == null) { 551 Log.e("OpenWnn", "not founds replace table"); 552 } else { 553 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.REPLACE_CHAR, replaceTable)); 554 mPrevInputKeyCode = primaryCode; 555 } 556 } 557 } 558 break; 559 560 case KEYCODE_SWITCH_FULL_HIRAGANA: 561 changeKeyMode(KEYMODE_JA_FULL_HIRAGANA); 562 break; 563 564 case KEYCODE_SWITCH_FULL_KATAKANA: 565 changeKeyMode(KEYMODE_JA_FULL_KATAKANA); 566 break; 567 568 case KEYCODE_SWITCH_FULL_ALPHABET: 569 changeKeyMode(KEYMODE_JA_FULL_ALPHABET); 570 break; 571 572 case KEYCODE_SWITCH_FULL_NUMBER: 573 changeKeyMode(KEYMODE_JA_FULL_NUMBER); 574 break; 575 576 case KEYCODE_SWITCH_HALF_KATAKANA: 577 changeKeyMode(KEYMODE_JA_HALF_KATAKANA); 578 break; 579 580 case KEYCODE_SWITCH_HALF_ALPHABET: 581 changeKeyMode(KEYMODE_JA_HALF_ALPHABET); 582 break; 583 584 case KEYCODE_SWITCH_HALF_NUMBER: 585 changeKeyMode(KEYMODE_JA_HALF_NUMBER); 586 break; 587 588 589 case KEYCODE_SELECT_CASE: 590 int shifted = (mShiftOn == 0) ? 1 : 0; 591 Keyboard newKeyboard = getShiftChangeKeyboard(shifted); 592 if (newKeyboard != null) { 593 mShiftOn = shifted; 594 changeKeyboard(newKeyboard); 595 } 596 break; 597 598 case KEYCODE_JP12_SPACE: 599 if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) { 600 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CONVERT)); 601 } else { 602 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, ' ')); 603 } 604 break; 605 606 case KEYCODE_EISU_KANA: 607 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, OpenWnnJAJP.ENGINE_MODE_EISU_KANA)); 608 break; 609 610 case KEYCODE_JP12_CLOSE: 611 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_KEY, 612 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK))); 613 break; 614 615 case KEYCODE_JP12_LEFT: 616 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, 617 new KeyEvent(KeyEvent.ACTION_DOWN, 618 KeyEvent.KEYCODE_DPAD_LEFT))); 619 break; 620 621 case KEYCODE_JP12_RIGHT: 622 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_SOFT_KEY, 623 new KeyEvent(KeyEvent.ACTION_DOWN, 624 KeyEvent.KEYCODE_DPAD_RIGHT))); 625 break; 626 case KEYCODE_NOP: 627 break; 628 629 default: 630 if (primaryCode >= 0) { 631 if (mKeyboardView.isShifted()) { 632 primaryCode = Character.toUpperCase(primaryCode); 633 } 634 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.INPUT_CHAR, (char)primaryCode)); 635 } 636 break; 637 } 638 639 /* update shift key's state */ 640 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) { 641 setShiftByEditorInfo(); 642 } 643 } 644 645 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#setPreferences */ 646 @Override public void setPreferences(SharedPreferences pref, EditorInfo editor) { 647 super.setPreferences(pref, editor); 648 649 int inputType = editor.inputType; 650 if (inputType == EditorInfo.TYPE_NULL) { 651 return; 652 } 653 654 mEnableAutoCaps = pref.getBoolean("auto_caps", true); 655 mFixedKeyMode = INVALID_KEYMODE; 656 mPreferenceKeyMode = INVALID_KEYMODE; 657 658 switch (inputType & EditorInfo.TYPE_MASK_CLASS) { 659 660 case EditorInfo.TYPE_CLASS_NUMBER: 661 case EditorInfo.TYPE_CLASS_DATETIME: 662 mPreferenceKeyMode = KEYMODE_JA_HALF_NUMBER; 663 break; 664 665 case EditorInfo.TYPE_CLASS_PHONE: 666 mFixedKeyMode = KEYMODE_JA_HALF_PHONE; 667 break; 668 669 case EditorInfo.TYPE_CLASS_TEXT: 670 switch (inputType & EditorInfo.TYPE_MASK_VARIATION) { 671 672 case EditorInfo.TYPE_TEXT_VARIATION_PASSWORD: 673 mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET; 674 break; 675 676 case EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS: 677 case EditorInfo.TYPE_TEXT_VARIATION_URI: 678 mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET; 679 break; 680 681 default: 682 break; 683 } 684 break; 685 686 default: 687 break; 688 } 689 690 if (inputType != mLastInputType) { 691 setDefaultKeyboard(); 692 mLastInputType = inputType; 693 } 694 695 setShiftByEditorInfo(); 696 } 697 698 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#onUpdateState */ 699 @Override public void onUpdateState(OpenWnn parent) { 700 super.onUpdateState(parent); 701 setShiftByEditorInfo(); 702 } 703 704 /** 705 * Change the keyboard to default 706 */ 707 public void setDefaultKeyboard() { 708 Locale locale = Locale.getDefault(); 709 int keymode = KEYMODE_JA_FULL_HIRAGANA; 710 711 if (mPreferenceKeyMode != INVALID_KEYMODE) { 712 keymode = mPreferenceKeyMode; 713 } else { 714 if (!locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) { 715 keymode = KEYMODE_JA_HALF_ALPHABET; 716 } 717 } 718 changeKeyMode(keymode); 719 } 720 721 722 /** 723 * Change to the next input mode 724 */ 725 private void nextKeyMode() { 726 boolean found = false; 727 int index; 728 for (index = 0; index < JP_MODE_CYCLE_TABLE.length; index++) { 729 if (JP_MODE_CYCLE_TABLE[index] == mCurrentKeyMode) { 730 found = true; 731 break; 732 } 733 } 734 735 if (!found) { 736 setDefaultKeyboard(); 737 } else { 738 index++; 739 if (JP_MODE_CYCLE_TABLE.length <= index) { 740 index = 0; 741 } 742 743 changeKeyMode(JP_MODE_CYCLE_TABLE[index]); 744 } 745 } 746 747 /** 748 * Create the keyboard for portrait mode 749 * <br> 750 * @param parent The context 751 */ 752 private void createKeyboardsPortrait(OpenWnn parent) { 753 Keyboard[][] keyList; 754 /* qwerty shift_off (portrait) */ 755 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; 756 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty); 757 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_alphabet); 758 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_symbols); 759 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_katakana); 760 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_alphabet); 761 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_symbols); 762 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_katakana); 763 keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); 764 765 /* qwerty shift_on (portrait) */ 766 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; 767 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = 768 mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA][0]; 769 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_alphabet_shift); 770 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_symbols_shift); 771 keyList[KEYMODE_JA_FULL_KATAKANA][0] = 772 mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA][0]; 773 keyList[KEYMODE_JA_HALF_ALPHABET][0] = 774 mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET][0]; 775 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_symbols_shift); 776 keyList[KEYMODE_JA_HALF_KATAKANA][0] = 777 mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA][0]; 778 keyList[KEYMODE_JA_HALF_PHONE][0] = 779 mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; 780 781 782 /* 12-keys shift_off (portrait) */ 783 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF]; 784 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp); 785 keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input); 786 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_alphabet); 787 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_input); 788 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_num); 789 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_katakana); 790 keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_katakana_input); 791 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_alphabet); 792 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_input); 793 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_num); 794 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_katakana); 795 keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_katakana_input); 796 keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone); 797 798 /* 12-keys shift_on (portrait) */ 799 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON]; 800 keyList[KEYMODE_JA_FULL_HIRAGANA] 801 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA]; 802 keyList[KEYMODE_JA_FULL_ALPHABET] 803 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET]; 804 keyList[KEYMODE_JA_FULL_NUMBER] 805 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER]; 806 keyList[KEYMODE_JA_FULL_KATAKANA] 807 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA]; 808 keyList[KEYMODE_JA_HALF_ALPHABET] 809 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];; 810 keyList[KEYMODE_JA_HALF_NUMBER] 811 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER]; 812 keyList[KEYMODE_JA_HALF_KATAKANA] 813 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA]; 814 keyList[KEYMODE_JA_HALF_PHONE] 815 = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE]; 816 817 } 818 819 /** 820 * Create the keyboard for landscape mode 821 * <br> 822 * @param parent The context 823 */ 824 private void createKeyboardsLandscape(OpenWnn parent) { 825 Keyboard[][] keyList; 826 /* qwerty shift_off (landscape) */ 827/* keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF]; 828 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_landscape); 829 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_alphabet_landscape); 830 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_symbols_landscape); 831 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_katakana_landscape); 832 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_alphabet_landscape); 833 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_symbols_landscape); 834 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_katakana_landscape); 835 keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone_landscape); 836*/ 837 /* qwerty shift_on (landscape) */ 838/* keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON]; 839 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = 840 mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA][0]; 841 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_alphabet_shift_landscape); 842 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_full_symbols_shift_landscape); 843 keyList[KEYMODE_JA_FULL_KATAKANA][0] = 844 mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA][0]; 845 keyList[KEYMODE_JA_HALF_ALPHABET][0] = 846 mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET][0]; 847 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_qwerty_half_symbols_shift_landscape); 848 keyList[KEYMODE_JA_HALF_KATAKANA][0] = 849 mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA][0]; 850 keyList[KEYMODE_JA_HALF_PHONE][0] = 851 mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0]; 852*/ 853 /* 12-keys shift_off (landscape) */ 854/* keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF]; 855 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp_landscape); 856 keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input_landscape); 857 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_landscape); 858 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_input_landscape); 859 keyList[KEYMODE_JA_FULL_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_num_landscape); 860 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_katakana_landscape); 861 keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_katakana_input_landscape); 862 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_landscape); 863 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_alphabet_input_landscape); 864 keyList[KEYMODE_JA_HALF_NUMBER][0] = new Keyboard(parent, R.xml.keyboard_12key_num_landscape); 865 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_katakana_landscape); 866 keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_katakana_input_landscape); 867 keyList[KEYMODE_JA_HALF_PHONE][0] = new Keyboard(parent, R.xml.keyboard_12key_phone_landscape); 868*/ 869 /* 12-keys shift_on (landscape) */ 870/* keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON]; 871 keyList[KEYMODE_JA_FULL_HIRAGANA] 872 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA]; 873 keyList[KEYMODE_JA_FULL_ALPHABET] 874 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET]; 875 keyList[KEYMODE_JA_FULL_NUMBER] 876 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER]; 877 keyList[KEYMODE_JA_FULL_KATAKANA] 878 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA]; 879 keyList[KEYMODE_JA_HALF_ALPHABET] 880 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];; 881 keyList[KEYMODE_JA_HALF_NUMBER] 882 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER]; 883 keyList[KEYMODE_JA_HALF_KATAKANA] 884 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA]; 885 keyList[KEYMODE_JA_HALF_PHONE] 886 = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE]; 887*/ 888 } 889 890 /** 891 * Convert the key code to the index of table 892 * <br> 893 * @param index The key code 894 * @return The index of the toggle table for input 895 */ 896 private int getTableIndex(int keyCode) { 897 int index = 898 (keyCode == KEYCODE_JP12_1) ? 0 : 899 (keyCode == KEYCODE_JP12_2) ? 1 : 900 (keyCode == KEYCODE_JP12_3) ? 2 : 901 (keyCode == KEYCODE_JP12_4) ? 3 : 902 (keyCode == KEYCODE_JP12_5) ? 4 : 903 (keyCode == KEYCODE_JP12_6) ? 5 : 904 (keyCode == KEYCODE_JP12_7) ? 6 : 905 (keyCode == KEYCODE_JP12_8) ? 7 : 906 (keyCode == KEYCODE_JP12_9) ? 8 : 907 (keyCode == KEYCODE_JP12_0) ? 9 : 908 (keyCode == KEYCODE_JP12_SHARP) ? 10 : 909 (keyCode == KEYCODE_JP12_ASTER) ? 11 : 910 0; 911 912 return index; 913 } 914 915 /** 916 * Get the toggle table for input that is appropriate in current mode. 917 * @return The toggle table for input 918 */ 919 private String[][] getCycleTable() { 920 String[][] cycleTable = null; 921 switch (mCurrentKeyMode) { 922 case KEYMODE_JA_FULL_HIRAGANA: 923 cycleTable = JP_FULL_HIRAGANA_CYCLE_TABLE; 924 break; 925 926 case KEYMODE_JA_FULL_KATAKANA: 927 cycleTable = JP_FULL_KATAKANA_CYCLE_TABLE; 928 break; 929 930 case KEYMODE_JA_FULL_ALPHABET: 931 cycleTable = JP_FULL_ALPHABET_CYCLE_TABLE; 932 break; 933 934 case KEYMODE_JA_FULL_NUMBER: 935 case KEYMODE_JA_HALF_NUMBER: 936 break; 937 938 case KEYMODE_JA_HALF_ALPHABET: 939 cycleTable = JP_HALF_ALPHABET_CYCLE_TABLE; 940 break; 941 942 case KEYMODE_JA_HALF_KATAKANA: 943 cycleTable = JP_HALF_KATAKANA_CYCLE_TABLE; 944 break; 945 946 default: 947 break; 948 } 949 return cycleTable; 950 } 951 952 /** 953 * Get the replace table that is appropriate in current mode. 954 * @return The replace table 955 */ 956 private HashMap getReplaceTable() { 957 HashMap hashTable = null; 958 switch (mCurrentKeyMode) { 959 case KEYMODE_JA_FULL_HIRAGANA: 960 hashTable = JP_FULL_HIRAGANA_REPLACE_TABLE; 961 break; 962 case KEYMODE_JA_FULL_KATAKANA: 963 hashTable = JP_FULL_KATAKANA_REPLACE_TABLE; 964 break; 965 966 case KEYMODE_JA_FULL_ALPHABET: 967 hashTable = JP_FULL_ALPHABET_REPLACE_TABLE; 968 break; 969 970 case KEYMODE_JA_FULL_NUMBER: 971 case KEYMODE_JA_HALF_NUMBER: 972 break; 973 974 case KEYMODE_JA_HALF_ALPHABET: 975 hashTable = JP_HALF_ALPHABET_REPLACE_TABLE; 976 break; 977 978 case KEYMODE_JA_HALF_KATAKANA: 979 hashTable = JP_HALF_KATAKANA_REPLACE_TABLE; 980 break; 981 982 default: 983 break; 984 } 985 return hashTable; 986 } 987 988 /** 989 * Set the status icon that is appropriate in current mode 990 */ 991 private void setStatusIcon() { 992 int icon = 0; 993 994 switch (mCurrentKeyMode) { 995 case KEYMODE_JA_FULL_HIRAGANA: 996 icon = R.drawable.immodeic_hiragana; 997 break; 998 case KEYMODE_JA_FULL_KATAKANA: 999 icon = R.drawable.immodeic_full_kana; 1000 break; 1001 case KEYMODE_JA_FULL_ALPHABET: 1002 icon = R.drawable.immodeic_full_alphabet; 1003 break; 1004 case KEYMODE_JA_FULL_NUMBER: 1005 icon = R.drawable.immodeic_full_number; 1006 break; 1007 case KEYMODE_JA_HALF_KATAKANA: 1008 icon = R.drawable.immodeic_half_kana; 1009 break; 1010 case KEYMODE_JA_HALF_ALPHABET: 1011 icon = R.drawable.immodeic_half_alphabet; 1012 break; 1013 case KEYMODE_JA_HALF_NUMBER: 1014 case KEYMODE_JA_HALF_PHONE: 1015 icon = R.drawable.immodeic_half_number; 1016 break; 1017 default: 1018 break; 1019 } 1020 1021 mWnn.showStatusIcon(icon); 1022 } 1023 1024 /** 1025 * Get the shift key state from the editor. 1026 * <br> 1027 * @param editor The editor information 1028 * @return The state id of the shift key (0:off, 1:on) 1029 */ 1030 protected int getShiftKeyState(EditorInfo editor) { 1031 int caps = mWnn.getCurrentInputConnection().getCursorCapsMode(editor.inputType); 1032 return (caps == 0) ? 0 : 1; 1033 } 1034 1035 /** 1036 * Set the shift key state from {@link EditorInfo}. 1037 */ 1038 private void setShiftByEditorInfo() { 1039 if (mEnableAutoCaps && (mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)) { 1040 int shift = getShiftKeyState(mWnn.getCurrentInputEditorInfo()); 1041 1042 mShiftOn = shift; 1043 changeKeyboard(getShiftChangeKeyboard(shift)); 1044 } 1045 } 1046 1047 /** @see jp.co.omronsoft.openwnn.DefaultSoftKeyboard#setHardKeyboardHidden */ 1048 @Override public void setHardKeyboardHidden(boolean hidden) { 1049 super.setHardKeyboardHidden(hidden); 1050 if ((mWnn != null) && !mHardKeyboardHidden) { 1051 mWnn.onEvent(new OpenWnnEvent(OpenWnnEvent.CHANGE_MODE, 1052 OpenWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY)); 1053 } 1054 } 1055} 1056 1057 1058 1059