src/com/hiroshica/android/input/nicownn2/JAJP/DefaultSoftKeyboardTest.java

   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  * test message
  17  */
  18
  19 package com.hiroshica.android.input.nicownn2.JAJP;
  20
  21 import android.view.KeyEvent;
  22 import android.view.inputmethod.EditorInfo;
  23 import android.view.inputmethod.InputConnection;
  24 import android.inputmethodservice.Keyboard;
  25 import android.util.Log;
  26 import android.view.View;
  27 import android.content.SharedPreferences;
  28
  29 import android.preference.PreferenceManager;
  30
  31
  32 import java.util.HashMap;
  33 import java.util.Locale;
  34 import java.util.List;
  35
  36 import com.hiroshica.android.input.nicownn2.*;
  37
  38 /**
  39  * The default Software Keyboard class for Japanese IME.
  40  *
  41  * @author Copyright (C) 2009 OMRON SOFTWARE CO., LTD.  All Rights Reserved.
  42  */
  43 public class DefaultSoftKeyboardTest extends DefaultSoftKeyboard {
  44
  45         /** Enable English word prediction on half-width alphabet mode */
  46         private static final boolean USE_ENGLISH_PREDICT = true;
  47
  48         /** Key code for switching to full-width alphabet mode */
  49         private static final int KEYCODE_SWITCH_FULL_ALPHABET = -303;
  50
  51         /** Key code for switching to full-width number mode */
  52         private static final int KEYCODE_SWITCH_FULL_NUMBER = -304;
  53
  54         /** Key code for switching to half-width alphabet mode */
  55         private static final int KEYCODE_SWITCH_HALF_ALPHABET = -307;
  56
  57         /** Key code for switching to half-width number mode */
  58         private static final int KEYCODE_SWITCH_HALF_NUMBER = -308;
  59
  60         /** Key code for case toggle key */
  61         private static final int KEYCODE_SELECT_CASE = -309;
  62
  63         /** Key code for EISU-KANA conversion */
  64         private static final int KEYCODE_EISU_KANA = -305;
  65
  66         /** Key code for switching to full-width Nicotouch mode */
  67         private static final int KEYCODE_SWITCH_FULL_NICO = -400;
  68
  69         /** Key code for NOP (no-operation) */
  70         private static final int KEYCODE_NOP = -310;
  71
  72
  73         /** Input mode toggle cycle table */
  74         private static final int[] JP_MODE_CYCLE_TABLE = {
  75                 KEYMODE_JA_FULL_NICO, KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER,
  76         };
  77
  78         /** Definition for {@code mInputType} (toggle) */
  79         private static final int INPUT_TYPE_TOGGLE = 1;
  80
  81         /** Definition for {@code mInputType} (commit instantly) */
  82         private static final int INPUT_TYPE_INSTANT = 2;
  83
  84         /** Max key number of the 12 key keyboard (depends on the definition of keyboards) */
  85         private static final int KEY_NUMBER_12KEY = 20;
  86
  87         /** Toggle cycle table for full-width alphabet */
  88         private static final String[][] JP_FULL_ALPHABET_CYCLE_TABLE = {
  89                 {"\uff0e", "\uff20", "\uff0d", "\uff3f", "\uff0f", "\uff1a", "\uff5e", "\uff11"},
  90                 {"\uff41", "\uff42", "\uff43", "\uff21", "\uff22", "\uff23", "\uff12"},
  91                 {"\uff44", "\uff45", "\uff46", "\uff24", "\uff25", "\uff26", "\uff13"},
  92                 {"\uff47", "\uff48", "\uff49", "\uff27", "\uff28", "\uff29", "\uff14"},
  93                 {"\uff4a", "\uff4b", "\uff4c", "\uff2a", "\uff2b", "\uff2c", "\uff15"},
  94                 {"\uff4d", "\uff4e", "\uff4f", "\uff2d", "\uff2e", "\uff2f", "\uff16"},
  95                 {"\uff50", "\uff51", "\uff52", "\uff53", "\uff30", "\uff31", "\uff32", "\uff33", "\uff17"},
  96                 {"\uff54", "\uff55", "\uff56", "\uff34", "\uff35", "\uff36", "\uff18"},
  97                 {"\uff57", "\uff58", "\uff59", "\uff5a", "\uff37", "\uff38", "\uff39", "\uff3a", "\uff19"},
  98                 {"\uff0d", "\uff10"},
  99                 {"\uff0c", "\uff0e", "\uff1f", "\uff01", "\u30fb", "\u3000"}
 100         };
 101
 102         /** Replace table for full-width alphabet */
 103         private static final HashMap<String,String> JP_FULL_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {
 104                 /**
 105                  *
 106                  */
 107                 private static final long serialVersionUID = 1L;
 108         {
 109                         put("\uff21", "\uff41"); put("\uff22", "\uff42"); put("\uff23", "\uff43"); put("\uff24", "\uff44"); put("\uff25", "\uff45");
 110                         put("\uff41", "\uff21"); put("\uff42", "\uff22"); put("\uff43", "\uff23"); put("\uff44", "\uff24"); put("\uff45", "\uff25");
 111                         put("\uff26", "\uff46"); put("\uff27", "\uff47"); put("\uff28", "\uff48"); put("\uff29", "\uff49"); put("\uff2a", "\uff4a");
 112                         put("\uff46", "\uff26"); put("\uff47", "\uff27"); put("\uff48", "\uff28"); put("\uff49", "\uff29"); put("\uff4a", "\uff2a");
 113                         put("\uff2b", "\uff4b"); put("\uff2c", "\uff4c"); put("\uff2d", "\uff4d"); put("\uff2e", "\uff4e"); put("\uff2f", "\uff4f");
 114                         put("\uff4b", "\uff2b"); put("\uff4c", "\uff2c"); put("\uff4d", "\uff2d"); put("\uff4e", "\uff2e"); put("\uff4f", "\uff2f");
 115                         put("\uff30", "\uff50"); put("\uff31", "\uff51"); put("\uff32", "\uff52"); put("\uff33", "\uff53"); put("\uff34", "\uff54");
 116                         put("\uff50", "\uff30"); put("\uff51", "\uff31"); put("\uff52", "\uff32"); put("\uff53", "\uff33"); put("\uff54", "\uff34");
 117                         put("\uff35", "\uff55"); put("\uff36", "\uff56"); put("\uff37", "\uff57"); put("\uff38", "\uff58"); put("\uff39", "\uff59");
 118                         put("\uff55", "\uff35"); put("\uff56", "\uff36"); put("\uff57", "\uff37"); put("\uff58", "\uff38"); put("\uff59", "\uff39");
 119                         put("\uff3a", "\uff5a");
 120                         put("\uff5a", "\uff3a");
 121                 }};
 122
 123         /** Toggle cycle table for half-width alphabet */
 124         private static final String[][] JP_HALF_ALPHABET_CYCLE_TABLE = {
 125                 {".", "@", "-", "_", "/", ":", "~", "1"},
 126                 {"a", "b", "c", "A", "B", "C", "2"},
 127                 {"d", "e", "f", "D", "E", "F", "3"},
 128                 {"g", "h", "i", "G", "H", "I", "4"},
 129                 {"j", "k", "l", "J", "K", "L", "5"},
 130                 {"m", "n", "o", "M", "N", "O", "6"},
 131                 {"p", "q", "r", "s", "P", "Q", "R", "S", "7"},
 132                 {"t", "u", "v", "T", "U", "V", "8"},
 133                 {"w", "x", "y", "z", "W", "X", "Y", "Z", "9"},
 134                 {"-", "0"},
 135                 {",", ".", "?", "!", ";", " "}
 136         };
 137
 138         /** Replace table for half-width alphabet */
 139         private static final HashMap<String,String> JP_HALF_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {
 140                 /**
 141                  *
 142                  */
 143                 private static final long serialVersionUID = 1L;
 144         {
 145                         put("A", "a"); put("B", "b"); put("C", "c"); put("D", "d"); put("E", "e");
 146                         put("a", "A"); put("b", "B"); put("c", "C"); put("d", "D"); put("e", "E");
 147                         put("F", "f"); put("G", "g"); put("H", "h"); put("I", "i"); put("J", "j");
 148                         put("f", "F"); put("g", "G"); put("h", "H"); put("i", "I"); put("j", "J");
 149                         put("K", "k"); put("L", "l"); put("M", "m"); put("N", "n"); put("O", "o");
 150                         put("k", "K"); put("l", "L"); put("m", "M"); put("n", "N"); put("o", "O");
 151                         put("P", "p"); put("Q", "q"); put("R", "r"); put("S", "s"); put("T", "t");
 152                         put("p", "P"); put("q", "Q"); put("r", "R"); put("s", "S"); put("t", "T");
 153                         put("U", "u"); put("V", "v"); put("W", "w"); put("X", "x"); put("Y", "y");
 154                         put("u", "U"); put("v", "V"); put("w", "W"); put("x", "X"); put("y", "Y");
 155                         put("Z", "z");
 156                         put("z", "Z");
 157                 }};
 158
 159
 160         /* */
 161         SetupKeyboard              mSetupKeyboard;
 162         String[][][]               mCycleTable;
 163         HashMap<String, String>    mReplaceTable;
 164
 165         /** Character table for full-width number */
 166         private static final char[] INSTANT_CHAR_CODE_FULL_NUMBER =
 167                 "\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19\uff10\uff03\uff0a".toCharArray();
 168
 169         /** Character table for half-width number */
 170         private static final char[] INSTANT_CHAR_CODE_HALF_NUMBER =
 171                 "1234567890#*".toCharArray();
 172
 173         /** The constant for mFixedKeyMode. It means that input mode is not fixed. */
 174         private static final int INVALID_KEYMODE = -1;
 175
 176         /** KeyIndex of "Moji" key on 12 keyboard (depends on the definition of keyboards) */
 177         private static final int KEY_INDEX_CHANGE_MODE_12KEY = 15;
 178
 179         /** KeyIndex of "Moji" key on QWERTY keyboard (depends on the definition of keyboards) */
 180         private static final int KEY_INDEX_CHANGE_MODE_QWERTY = 29;
 181
 182         /** Type of input mode */
 183         private int mInputType = INPUT_TYPE_TOGGLE;
 184
 185         /** Previous input character code */
 186         private int mPrevInputKeyCode = 0;
 187
 188         /** flick nicoinput **/
 189         private static final int NICOFLICK_NONE       = 0;
 190         private static final int NICOFLICK_1STROKE    = 1;
 191         private static final int NICOFLICK_NICOSTROKE = 2;
 192
 193         private int mFlickNicoInput = 0;
 194         private boolean mNicoFlick = false;
 195         private static final HashMap<String, Integer> flickModeTable = new HashMap<String, Integer>() {
 196                 /**
 197                  *
 198                  */
 199                 private static final long serialVersionUID = 1L;
 200
 201         {
 202                         put("none_flick", 0);
 203                         put("normal_stroke", 1);
 204                         put("nico_stroke", 2);
 205                 }};
 206
 207         private static final NicoWnnEvent mEventTouchOtherKey    = new NicoWnnEvent(NicoWnnEvent.TOUCH_OTHER_KEY);
 208         private static final NicoWnnEvent mEventCommitText       = new NicoWnnEvent(NicoWnnEvent.COMMIT_COMPOSING_TEXT);
 209         private static final NicoWnnEvent mEventConvert          = new NicoWnnEvent(NicoWnnEvent.CONVERT);
 210
 211         private static final NicoWnnEvent mEventChangeMode12Key    = new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY);
 212         private static final NicoWnnEvent mEventChangeModeQwerty   = new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY);
 213         private static final NicoWnnEvent mEventChangeModeSymbol   = new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_SYMBOL);
 214         private static final NicoWnnEvent mEventChangeModeDocomo   = new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_DOCOMOSYMBOL);
 215         private static final NicoWnnEvent mEventChangeModeEisuKana = new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_EISU_KANA);
 216
 217         private static final NicoWnnEvent mEventInputShiftLeft   = new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_SHIFT_LEFT));
 218
 219         private static final NicoWnnEvent mEventInputKeyDel      = new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL));
 220         private static final NicoWnnEvent mEventInputEnter       = new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER));
 221         private static final NicoWnnEvent mEventInputBack        = new NicoWnnEvent(NicoWnnEvent.INPUT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK));
 222         private static final NicoWnnEvent mEventInputDpadLeft    = new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_LEFT));
 223         private static final NicoWnnEvent mEventInputDpadRight   = new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_RIGHT));
 224
 225
 226         /**
 227          * Character table to input when mInputType becomes INPUT_TYPE_INSTANT.
 228          * (Either INSTANT_CHAR_CODE_FULL_NUMBER or INSTANT_CHAR_CODE_HALF_NUMBER)
 229          */
 230         private char[] mCurrentInstantTable = null;
 231
 232         /** Input mode that is not able to be changed. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */
 233         private int[] mLimitedKeyMode = null;
 234
 235         /** Input mode that is given the first priority. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */
 236         private int mPreferenceKeyMode = INVALID_KEYMODE;
 237
 238         /** The last input type */
 239         private int mLastInputType = 0;
 240
 241         /** Auto caps mode */
 242         private boolean mEnableAutoCaps = true;
 243
 244         /** PopupResId of "Moji" key (this is used for canceling long-press) */
 245         private int mPopupResId = 0;
 246
 247         /** Whether the InputType is null */
 248         private boolean mIsInputTypeNull = false;
 249
 250         /** {@code SharedPreferences} for save the keyboard type */
 251         private SharedPreferences.Editor mPrefEditor = null;
 252
 253         /** "Moji" key (this is used for canceling long-press) */
 254         private Keyboard.Key mChangeModeKey = null;
 255
 256         private boolean mNicoFirst = false;
 257
 258         private Keyboard[][] mNicoKeyboard;
 259
 260         private boolean mGetNoFlipScreen = false;
 261         private boolean mNoFlipScreen = false;
 262
 263         /** option keyboard type */
 264         private int     mHookStockKeyType;
 265
 266         /** change eisu change mode **/
 267         private boolean mChange12keyQwertyMode = false;
 268         private final int[] m12keyTable = {
 269                 KEYBOARD_12KEY,  KEYBOARD_12KEY, KEYBOARD_QWERTY, KEYBOARD_QWERTY,  KEYBOARD_12KEY, KEYBOARD_QWERTY, KEYBOARD_QWERTY,  KEYBOARD_12KEY,  KEYBOARD_12KEY
 270         };
 271         /** option bell type **/
 272         private final int ALPHAMODE_SMALL = 0;
 273         private final int ALPHAMODE_BIG   = 1;
 274         private int mChangeAlphaBigMode = ALPHAMODE_SMALL;
 275
 276         /** Default constructor */
 277         public DefaultSoftKeyboardTest(SetupKeyboard keyboard) {
 278                 mSetupKeyboard       = keyboard;
 279                 mCycleTable   = keyboard.SetupCycleTable();
 280                 mReplaceTable = keyboard.SetupReplaceTable();
 281
 282                 mCurrentLanguage     = LANG_JA;
 283                 mCurrentKeyboardType = KEYBOARD_12KEY;
 284                 mHookStockKeyType    = KEYBOARD_12KEY;
 285                 mShiftOn             = KEYBOARD_SHIFT_OFF;
 286                 mCurrentKeyMode      = KEYMODE_JA_FULL_NICO;
 287                 mCurrentSlide        = NICO_SLIDE_MODE_TOP;
 288         }
 289
 290         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#createKeyboards */
 291         @Override protected void createKeyboards(NicoWnn parent) {
 292
 293                 /* Keyboard[# of Languages][portrait/landscape][# of keyboard type][shift off/on][max # of key-modes][noinput/input] */
 294                 mKeyboard = new Keyboard[3][2][4][2][9][2];
 295
 296                 SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(parent);
 297                 mChange12keyQwertyMode = pref.getBoolean("change_12key_qwerty", false);
 298                 boolean getalphamode  = pref.getBoolean("change_alphamode", false);
 299                 mGetNoFlipScreen       = pref.getBoolean("no_flip_screen", false);
 300                 mFlickNicoInput        = flickModeTable.get(pref.getString("nicoflick_mode", "none_flick"));
 301
 302                 if (false == getalphamode) {
 303                         mChangeAlphaBigMode = ALPHAMODE_SMALL;
 304                 }
 305                 else{
 306                         mChangeAlphaBigMode = ALPHAMODE_BIG;
 307                 }
 308
 309                 if (true == mGetNoFlipScreen) {
 310                         mNoFlipScreen = true;
 311                 }
 312                 else{
 313                         mNoFlipScreen = false;
 314                 }
 315
 316                 /* Create the suitable keyboard object */
 317                 if (mDisplayMode == DefaultSoftKeyboard.PORTRAIT) {
 318                         //mCurrentKeyboardType = KEYBOARD_12KEY;
 319                         createKeyboardsPortrait(parent);
 320                 } else {
 321                         //mCurrentKeyboardType = KEYBOARD_QWERTY;
 322                         createKeyboardsLandscape(parent);
 323                 }
 324
 325                 if (mCurrentKeyboardType == KEYBOARD_12KEY) {
 326                         mWnn.onEvent(mEventChangeMode12Key);
 327                 } else {
 328                         mWnn.onEvent(mEventChangeModeQwerty);
 329                 }
 330         }
 331
 332         /**
 333          * Commit the pre-edit string for committing operation that is not explicit
 334          * (ex. when a candidate is selected)
 335          */
 336         private void commitText() {
 337                 if (!mNoInput) {
 338                         mWnn.onEvent(mEventCommitText);
 339                 }
 340         }
 341
 342         /**
 343          * Change input mode
 344          * <br>
 345          * @param keyMode   The type of input mode
 346          */
 347         public void changeKeyMode(int keyMode) {
 348                 int targetMode = filterKeyMode(keyMode);
 349                 if (targetMode == INVALID_KEYMODE) {
 350                         return;
 351                 }
 352
 353                 commitText();
 354
 355                 if (mCapsLock) {
 356                         mWnn.onEvent(mEventInputShiftLeft);
 357                         mCapsLock = false;
 358                 }
 359                 mShiftOn = KEYBOARD_SHIFT_OFF;
 360                 Keyboard kbd = getModeChangeKeyboard(targetMode);
 361                 mCurrentKeyMode = targetMode;
 362                 mPrevInputKeyCode = 0;
 363                 mCurrentSlide = 0;
 364
 365                 int mode = NicoWnnEvent.Mode.DIRECT;
 366
 367                 switch (targetMode) {
 368                 case KEYMODE_JA_HALF_ALPHABET:
 369                         if (USE_ENGLISH_PREDICT) {
 370                                 mInputType = INPUT_TYPE_TOGGLE;
 371                                 mode = NicoWnnEvent.Mode.NO_LV1_CONV;
 372                         } else {
 373                                 mInputType = INPUT_TYPE_TOGGLE;
 374                                 mode = NicoWnnEvent.Mode.DIRECT;
 375                         }
 376                         break;
 377
 378                 case KEYMODE_JA_FULL_NUMBER:
 379                         mInputType = INPUT_TYPE_INSTANT;
 380                         mode = NicoWnnEvent.Mode.DIRECT;
 381                         mCurrentInstantTable = INSTANT_CHAR_CODE_FULL_NUMBER;
 382                         break;
 383
 384                 case KEYMODE_JA_HALF_NUMBER:
 385                         mInputType = INPUT_TYPE_INSTANT;
 386                         mode = NicoWnnEvent.Mode.DIRECT;
 387                         mCurrentInstantTable = INSTANT_CHAR_CODE_HALF_NUMBER;
 388                         break;
 389
 390                 case KEYMODE_JA_FULL_ALPHABET:
 391                         mInputType = INPUT_TYPE_TOGGLE;
 392                         mode = NicoWnnEvent.Mode.DIRECT;
 393                         break;
 394
 395                 case KEYMODE_JA_FULL_NICO:
 396                         mInputType = INPUT_TYPE_TOGGLE;
 397                         mode = NicoWnnEvent.Mode.DEFAULT;
 398                         mNicoFirst = false;
 399                         mNicoFlick = false;
 400                         break;
 401
 402                 default:
 403                         break;
 404                 }
 405
 406                 setStatusIcon();
 407                 changeKeyboard(kbd);
 408                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, mode));
 409                 if (mChange12keyQwertyMode == true) {
 410                         changeKeyboardType(m12keyTable[targetMode]);
 411                 }
 412         }
 413
 414         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#initView */
 415         @Override public View initView(NicoWnn parent, int width, int height) {
 416                 View view = super.initView(parent, width, height);
 417                 changeKeyboard(mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mCurrentKeyMode][0]);
 418                 return view;
 419         }
 420
 421         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#changeKeyboard */
 422         @Override protected boolean changeKeyboard(Keyboard keyboard) {
 423
 424                 if (keyboard != null) {
 425                         if (mIsInputTypeNull) {
 426                                 mChangeModeKey.popupResId = mPopupResId;
 427                         }
 428
 429                         List<Keyboard.Key> keys = keyboard.getKeys();
 430                         int keyIndex = (KEY_NUMBER_12KEY < keys.size())
 431                                 ? KEY_INDEX_CHANGE_MODE_QWERTY : KEY_INDEX_CHANGE_MODE_12KEY;
 432                         mChangeModeKey = keys.get(keyIndex);
 433
 434                         if (mIsInputTypeNull) {
 435                                 mPopupResId = mChangeModeKey.popupResId;
 436                                 mChangeModeKey.popupResId = 0;
 437                         }
 438                 }
 439                 return super.changeKeyboard(keyboard);
 440         }
 441
 442         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#changeKeyboardType */
 443         @Override public void changeKeyboardType(int type) {
 444                 commitText();
 445                 Keyboard kbd = getTypeChangeKeyboard(type);
 446                 if (kbd != null) {
 447                         mCurrentKeyboardType = type;
 448                         mPrefEditor.putBoolean("opt_enable_qwerty", type == KEYBOARD_QWERTY);
 449                         mPrefEditor.commit();
 450                         changeKeyboard(kbd);
 451                 }
 452                 if (type == KEYBOARD_12KEY) {
 453                         mWnn.onEvent(mEventChangeMode12Key);
 454                 } else {
 455                         mWnn.onEvent(mEventChangeModeQwerty);
 456                 }
 457         }
 458         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#setPreferences */
 459         @Override public void setPreferences(SharedPreferences pref, EditorInfo editor) {
 460                 mPrefEditor = pref.edit();
 461                 boolean isQwerty = pref.getBoolean("opt_enable_qwerty", false);
 462                 if (isQwerty && (mCurrentKeyboardType != KEYBOARD_QWERTY)) {
 463                         changeKeyboardType(KEYBOARD_QWERTY);
 464                 }
 465
 466                 super.setPreferences(pref, editor);
 467
 468                 int inputType = editor.inputType;
 469                 if (mHardKeyboardHidden) {
 470                         if (inputType == EditorInfo.TYPE_NULL) {
 471                                 if (!mIsInputTypeNull) {
 472                                         mIsInputTypeNull = true;
 473                                         mPopupResId = mChangeModeKey.popupResId;
 474                                         mChangeModeKey.popupResId = 0;
 475                                 }
 476                                 return;
 477                         }
 478
 479                         if (mIsInputTypeNull) {
 480                                 mIsInputTypeNull = false;
 481                                 mChangeModeKey.popupResId = mPopupResId;
 482                         }
 483                 }
 484
 485                 mEnableAutoCaps = pref.getBoolean("auto_caps", true);
 486                 mLimitedKeyMode = null;
 487                 mPreferenceKeyMode = INVALID_KEYMODE;
 488                 mNoInput = true;
 489                 mDisableKeyInput = false;
 490                 mCapsLock = false;
 491
 492                 switch (inputType & EditorInfo.TYPE_MASK_CLASS) {
 493
 494                 case EditorInfo.TYPE_CLASS_NUMBER:
 495                 case EditorInfo.TYPE_CLASS_DATETIME:
 496                         mPreferenceKeyMode = KEYMODE_JA_HALF_NUMBER;
 497                         break;
 498
 499                 case EditorInfo.TYPE_CLASS_PHONE:
 500                         if (mHardKeyboardHidden) {
 501                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_FULL_NICO};
 502                                 mPreferenceKeyMode = KEYMODE_JA_FULL_NICO;
 503                         } else {
 504                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET};
 505                                 mPreferenceKeyMode = KEYMODE_JA_FULL_NICO;
 506                         }
 507                         break;
 508
 509                 case EditorInfo.TYPE_CLASS_TEXT:
 510                         switch (inputType & EditorInfo.TYPE_MASK_VARIATION) {
 511
 512                         case EditorInfo.TYPE_TEXT_VARIATION_PASSWORD:
 513                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER};
 514                                 break;
 515
 516                         case EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS:
 517                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER};
 518                                 break;
 519                         case EditorInfo.TYPE_TEXT_VARIATION_URI:
 520                                 //mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET;
 521                                 mPreferenceKeyMode = KEYMODE_JA_FULL_NICO;
 522                                 break;
 523
 524                         default:
 525                                 break;
 526                         }
 527                         break;
 528
 529                 default:
 530                         break;
 531                 }
 532
 533                 boolean restartkey = false;
 534                 boolean old12keyqwerty = mChange12keyQwertyMode;
 535
 536                 mChange12keyQwertyMode = pref.getBoolean("change_12key_qwerty", false);
 537                 boolean getalphamode  = pref.getBoolean("change_alphamode", false);
 538                 mGetNoFlipScreen       = pref.getBoolean("no_flip_screen", false);
 539                 mFlickNicoInput        = flickModeTable.get(pref.getString("nicoflick_mode", "none_flick"));
 540
 541                 if (false == getalphamode) {
 542                         mChangeAlphaBigMode = ALPHAMODE_SMALL;
 543                 }
 544                 else{
 545                         mChangeAlphaBigMode = ALPHAMODE_BIG;
 546                 }
 547
 548                 if (true == mGetNoFlipScreen) {
 549                         mNoFlipScreen = true;
 550                 }
 551                 else{
 552                         mNoFlipScreen = false;
 553                 }
 554
 555                 if (old12keyqwerty != mChange12keyQwertyMode) {
 556                         restartkey = true;
 557                         if (false == mChange12keyQwertyMode) {
 558                                 mCurrentKeyboardType = mHookStockKeyType; // change last keyboard type.
 559                         }
 560                 }
 561
 562                 if (inputType != mLastInputType) {
 563                         setDefaultKeyboard();
 564                         mLastInputType = inputType;
 565                 }
 566                 else if (true == restartkey) {
 567                         setDefaultKeyboard();
 568                 }
 569
 570                 setStatusIcon();
 571                 setShiftByEditorInfo();
 572         }
 573
 574         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#onUpdateState */
 575         @Override public void onUpdateState(NicoWnn parent) {
 576                 super.onUpdateState(parent);
 577                 if (!mCapsLock) {
 578                         setShiftByEditorInfo();
 579                         if (true == mNoInput && true == mNicoFirst) {
 580                                 resetNicoKeyboard();
 581                         }
 582                 }
 583         }
 584         /**
 585          * Change the keyboard to default
 586          */
 587         public void setDefaultKeyboard() {
 588                 Locale locale = Locale.getDefault();
 589                 int keymode = KEYMODE_JA_FULL_NICO;
 590
 591
 592                 if (mPreferenceKeyMode != INVALID_KEYMODE) {
 593                         keymode = mPreferenceKeyMode;
 594                 } else if (mLimitedKeyMode != null) {
 595                         keymode = mLimitedKeyMode[0];
 596                 } else {
 597                         if (!locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) {
 598                                 keymode = KEYMODE_JA_HALF_ALPHABET;
 599                         }
 600                 }
 601
 602                 changeKeyMode(keymode);
 603         }
 604
 605
 606         /**
 607          * Change to the next input mode
 608          */
 609         public void nextKeyMode() {
 610                 /* Search the current mode in the toggle table */
 611                 boolean found = false;
 612                 int index;
 613                 for (index = 0; index < JP_MODE_CYCLE_TABLE.length; index++) {
 614                         if (JP_MODE_CYCLE_TABLE[index] == mCurrentKeyMode) {
 615                                 found = true;
 616                                 break;
 617                         }
 618                 }
 619
 620                 if (!found) {
 621                         /* If the current mode not exists, set the default mode */
 622                         setDefaultKeyboard();
 623                 } else {
 624                         /* If the current mode exists, set the next input mode */
 625                         int size = JP_MODE_CYCLE_TABLE.length;
 626                         int keyMode = INVALID_KEYMODE;
 627                         for (int i = 0; i < size; i++) {
 628                                 index = (++index) % size;
 629
 630                                 keyMode = filterKeyMode(JP_MODE_CYCLE_TABLE[index]);
 631                                 if (keyMode != INVALID_KEYMODE) {
 632                                         break;
 633                                 }
 634                         }
 635
 636                         if (keyMode != INVALID_KEYMODE) {
 637                                 changeKeyMode(keyMode);
 638                         }
 639                 }
 640         }
 641
 642         /**
 643          * Create the keyboard for portrait mode
 644          * <br>
 645          * @param parent  The context
 646          */
 647         private void createKeyboardsPortrait(NicoWnn parent) {
 648                 Keyboard[][] keyList;
 649                 /* qwerty shift_off (portrait) */
 650                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF];
 651                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet);
 652                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols);
 653                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet);
 654                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols);
 655                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);
 656                 keyList[KEYMODE_JA_FULL_NICO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp);
 657
 658                 /* qwerty shift_on (portrait) */
 659                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON];
 660                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift);
 661                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift);
 662                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift);
 663                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift);
 664                 keyList[KEYMODE_JA_HALF_PHONE][0]    = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0];
 665                 keyList[KEYMODE_JA_FULL_NICO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift);
 666
 667                 /* 12-keys shift_off (portrait) */
 668                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 669                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);
 670
 671                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet);
 672                 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input);
 673                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_num);
 674                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet);
 675                 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input);
 676                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_half_num);
 677
 678                 /* 12-keys shift_on (portrait) */
 679                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 680                 keyList[KEYMODE_JA_HALF_PHONE]    = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE];
 681
 682                 keyList[KEYMODE_JA_FULL_ALPHABET] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET];
 683                 keyList[KEYMODE_JA_FULL_NUMBER]   = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER];
 684                 keyList[KEYMODE_JA_HALF_ALPHABET] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];;
 685                 keyList[KEYMODE_JA_HALF_NUMBER]   = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER];
 686
 687                 mNicoKeyboard = mSetupKeyboard.SetupSoftKeyboard(parent, PORTRAIT);
 688
 689                 Keyboard[][] keyListOn;
 690                 keyList   = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 691                 keyListOn = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 692                 keyList[KEYMODE_JA_FULL_NICO]     = mNicoKeyboard[NICO_SLIDE_MODE_TOP];
 693                 keyListOn[KEYMODE_JA_FULL_NICO]   = mNicoKeyboard[NICO_SLIDE_MODE_A];
 694         }
 695
 696         /**
 697          * Create the keyboard for landscape mode
 698          * <br>
 699          * @param parent  The context
 700          */
 701         private void createKeyboardsLandscape(NicoWnn parent) {
 702                 Keyboard[][] keyList;
 703                 /* qwerty shift_off (landscape) */
 704                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF];
 705                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_land);
 706                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_land);
 707                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_land);
 708                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_land);
 709                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone_land);
 710                 keyList[KEYMODE_JA_FULL_NICO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp_land);
 711
 712                 /* qwerty shift_on (landscape) */
 713                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON];
 714                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift_land);
 715                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift_land);
 716                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift_land);
 717                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift_land);
 718                 keyList[KEYMODE_JA_HALF_PHONE][0]    = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0];
 719                 keyList[KEYMODE_JA_FULL_NICO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift_land);
 720
 721                 /* 12-keys shift_off (landscape) */
 722                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 723                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_land);
 724                 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input_land);
 725                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_num_land);
 726                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_land);
 727                 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input_land);
 728                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_half_num_land);
 729                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone_land);
 730
 731                 /* 12-keys shift_on (landscape) */
 732                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 733                 keyList[KEYMODE_JA_FULL_ALPHABET] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET];
 734                 keyList[KEYMODE_JA_FULL_NUMBER]   = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER];
 735                 keyList[KEYMODE_JA_HALF_ALPHABET] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];;
 736                 keyList[KEYMODE_JA_HALF_NUMBER]   = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER];
 737                 keyList[KEYMODE_JA_HALF_PHONE]    = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE];
 738
 739                 mNicoKeyboard = mSetupKeyboard.SetupSoftKeyboard(parent, LANDSCAPE);
 740
 741                 Keyboard[][] keyListOn;
 742                 keyList   = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 743                 keyListOn = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 744                 keyList[KEYMODE_JA_FULL_NICO]     = mNicoKeyboard[NICO_SLIDE_MODE_TOP];
 745                 keyListOn[KEYMODE_JA_FULL_NICO]   = mNicoKeyboard[NICO_SLIDE_MODE_A];
 746         }
 747
 748         /**
 749          * Convert the key code to the index of table
 750          * <br>
 751          * @param index     The key code
 752          * @return          The index of the toggle table for input
 753          */
 754         private int getTableIndex(int keyCode) {
 755                 int index =
 756                         (keyCode == KEYCODE_JP12_1)     ?  0 :
 757                         (keyCode == KEYCODE_JP12_2)     ?  1 :
 758                         (keyCode == KEYCODE_JP12_3)     ?  2 :
 759                         (keyCode == KEYCODE_JP12_4)     ?  3 :
 760                         (keyCode == KEYCODE_JP12_5)     ?  4 :
 761                         (keyCode == KEYCODE_JP12_6)     ?  5 :
 762                         (keyCode == KEYCODE_JP12_7)     ?  6 :
 763                         (keyCode == KEYCODE_JP12_8)     ?  7 :
 764                         (keyCode == KEYCODE_JP12_9)     ?  8 :
 765                         (keyCode == KEYCODE_JP12_0)     ?  9 :
 766                         (keyCode == KEYCODE_JP12_SHARP) ? 10 :
 767                         (keyCode == KEYCODE_JP12_ASTER) ? 11 :
 768                         0;
 769
 770                 return index;
 771         }
 772
 773         /**
 774          * Get the toggle table for input that is appropriate in current mode.
 775          *
 776          * @return      The toggle table for input
 777          */
 778         private String[][] getCycleTable() {
 779                 String[][] cycleTable = null;
 780                 switch (mCurrentKeyMode) {
 781                 case KEYMODE_JA_FULL_ALPHABET:
 782                         cycleTable = JP_FULL_ALPHABET_CYCLE_TABLE;
 783                         break;
 784
 785                 case KEYMODE_JA_FULL_NUMBER:
 786                 case KEYMODE_JA_HALF_NUMBER:
 787                         /* Because these modes belong to direct input group, No toggle table exists */
 788                         break;
 789
 790                 case KEYMODE_JA_HALF_ALPHABET:
 791                         cycleTable = JP_HALF_ALPHABET_CYCLE_TABLE;
 792                         break;
 793
 794                 case KEYMODE_JA_FULL_NICO:
 795                         cycleTable = mCycleTable[mChangeAlphaBigMode];
 796                         break;
 797
 798                 default:
 799                         break;
 800                 }
 801                 return cycleTable;
 802         }
 803
 804         /**
 805          * Get the replace table that is appropriate in current mode.
 806          *
 807          * @return      The replace table
 808          */
 809         private HashMap<String,String> getReplaceTable() {
 810                 HashMap<String,String> hashTable = null;
 811                 switch (mCurrentKeyMode) {
 812                 case KEYMODE_JA_FULL_ALPHABET:
 813                         hashTable = JP_FULL_ALPHABET_REPLACE_TABLE;
 814                         break;
 815
 816                 case KEYMODE_JA_FULL_NUMBER:
 817                 case KEYMODE_JA_HALF_NUMBER:
 818                         /* Because these modes belong to direct input group, No replacing table exists */
 819                         break;
 820
 821                 case KEYMODE_JA_HALF_ALPHABET:
 822                         hashTable = JP_HALF_ALPHABET_REPLACE_TABLE;
 823                         break;
 824
 825                 case KEYMODE_JA_FULL_NICO:
 826                         hashTable = mReplaceTable;
 827                         break;
 828
 829                 default:
 830                         break;
 831                 }
 832                 return hashTable;
 833         }
 834
 835         /**
 836          * Set the status icon that is appropriate in current mode
 837          */
 838         private void setStatusIcon() {
 839                 int icon = 0;
 840
 841                 switch (mCurrentKeyMode) {
 842                 case KEYMODE_JA_FULL_ALPHABET:
 843                         icon = R.drawable.immodeic_full_alphabet;
 844                         break;
 845                 case KEYMODE_JA_FULL_NUMBER:
 846                         icon = R.drawable.immodeic_full_number;
 847                         break;
 848                 case KEYMODE_JA_HALF_ALPHABET:
 849                         icon = R.drawable.immodeic_half_alphabet;
 850                         break;
 851                 case KEYMODE_JA_HALF_NUMBER:
 852                 case KEYMODE_JA_HALF_PHONE:
 853                         icon = R.drawable.immodeic_half_number;
 854                         break;
 855                 case KEYMODE_JA_FULL_NICO:
 856                         icon = mSetupKeyboard.SetupIcon();
 857                         break;
 858
 859                 default:
 860                         break;
 861                 }
 862
 863                 mWnn.showStatusIcon(icon);
 864         }
 865
 866         /**
 867          * Get the shift key state from the editor.
 868          * <br>
 869          * @param editor    The editor information
 870          * @return          The state id of the shift key (0:off, 1:on)
 871          */
 872         protected int getShiftKeyState(EditorInfo editor) {
 873                 InputConnection connection = mWnn.getCurrentInputConnection();
 874                 if (connection != null) {
 875                         int caps = connection.getCursorCapsMode(editor.inputType);
 876                         return (caps == 0) ? 0 : 1;
 877                 } else {
 878                         return 0;
 879                 }
 880         }
 881
 882         /**
 883          * Set the shift key state from {@link EditorInfo}.
 884          */
 885         private void setShiftByEditorInfo() {
 886                 if (mEnableAutoCaps && (mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)) {
 887                         int shift = getShiftKeyState(mWnn.getCurrentInputEditorInfo());
 888
 889                         mShiftOn = shift;
 890                         changeKeyboard(getShiftChangeKeyboard(shift));
 891                 }
 892         }
 893
 894         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#setHardKeyboardHidden */
 895         @Override public void setHardKeyboardHidden(boolean hidden) {
 896                 if (mWnn != null) {
 897                         if (!hidden) {
 898                                 mWnn.onEvent(mEventChangeModeQwerty);
 899                         }
 900
 901                         if (mHardKeyboardHidden != hidden) {
 902                                 if ((mLimitedKeyMode != null)
 903                                     || ((mCurrentKeyMode != KEYMODE_JA_FULL_NICO) && (mCurrentKeyMode != KEYMODE_JA_HALF_ALPHABET))) {
 904
 905                                         mLastInputType = EditorInfo.TYPE_NULL;
 906                                         if (mWnn.isInputViewShown()) {
 907                                                 setDefaultKeyboard();
 908                                         }
 909                                 }
 910                         }
 911                 }
 912                 super.setHardKeyboardHidden(hidden);
 913         }
 914
 915         /**
 916          * Change the key-mode to the allowed one which is restricted
 917          *  by the text input field or the type of the keyboard.
 918          * @param keyMode The key-mode
 919          * @return the key-mode allowed
 920          */
 921         private int filterKeyMode(int keyMode) {
 922                 int targetMode = keyMode;
 923                 int[] limits = mLimitedKeyMode;
 924
 925                 if (!mHardKeyboardHidden) { /* for hardware keyboard */
 926                         if ((targetMode != KEYMODE_JA_FULL_NICO) && (targetMode != KEYMODE_JA_HALF_ALPHABET)) {
 927                                 Locale locale = Locale.getDefault();
 928                                 int keymode = KEYMODE_JA_HALF_ALPHABET;
 929                                 if (locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) {
 930                                         switch (targetMode) {
 931                                         case KEYMODE_JA_FULL_NICO:
 932                                                 // hiromitsu-s!!! 2009-09-23 12:47:08
 933                                                 //keymode = KEYMODE_JA_FULL_NICO;
 934                                                 break;
 935                                         default:
 936                                                 /* half-alphabet */
 937                                                 break;
 938                                         }
 939                                 }
 940                                 targetMode = keymode;
 941                         }
 942                 }
 943
 944                 /* restrict by the type of the text field */
 945                 if (limits != null) {
 946                         boolean hasAccepted = false;
 947                         boolean hasRequiredChange = true;
 948                         int size = limits.length;
 949                         int nowMode = mCurrentKeyMode;
 950
 951                         for (int i = 0; i < size; i++) {
 952                                 if (targetMode == limits[i]) {
 953                                         hasAccepted = true;
 954                                         break;
 955                                 }
 956                                 if (nowMode == limits[i]) {
 957                                         hasRequiredChange = false;
 958                                 }
 959                         }
 960
 961                         if (!hasAccepted) {
 962                                 if (hasRequiredChange) {
 963                                         targetMode = mLimitedKeyMode[0];
 964                                 } else {
 965                                         targetMode = INVALID_KEYMODE;
 966                                 }
 967                         }
 968                 }
 969
 970                 return targetMode;
 971         }
 972
 973
 974
 975         /*****************************************
 976          * onkey (normal)
 977          */
 978         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#onKey */
 979         @Override public void onKey(int primaryCode, int[] keyCodes) {
 980
 981                 if (mDisableKeyInput) {
 982                         return;
 983                 }
 984
 985                 if (mCurrentKeyMode == KEYMODE_JA_FULL_NICO) {
 986                         if (true == onKeyNico(primaryCode, keyCodes)) {
 987                                 /* update shift key's state */
 988                                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
 989                                         setShiftByEditorInfo();
 990                                 }
 991                                 return;
 992                         }
 993                 }
 994                 switch (primaryCode) {
 995                 case KEYCODE_JP12_TOGGLE_MODE:
 996                 case KEYCODE_QWERTY_TOGGLE_MODE:
 997                         if (!mIsInputTypeNull) {
 998                                 nextKeyMode();
 999                         }
1000                         break;
1001
1002                 case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE:
1003                 case KEYCODE_JP12_BACKSPACE:
1004                         mWnn.onEvent(mEventInputKeyDel);
1005                         break;
1006
1007                 case DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT:
1008                         toggleShiftLock();
1009                         break;
1010
1011                 case DefaultSoftKeyboard.KEYCODE_QWERTY_ALT:
1012                         processAltKey();
1013                         break;
1014
1015                 case KEYCODE_QWERTY_ENTER:
1016                 case KEYCODE_JP12_ENTER:
1017                         mWnn.onEvent(mEventInputEnter);
1018                         break;
1019
1020                 case KEYCODE_JP12_REVERSE:
1021                         if (!mNoInput) {
1022                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_REVERSE_CHAR, mCurrentCycleTable));
1023                         }
1024                         break;
1025
1026                 case KEYCODE_QWERTY_KBD:
1027                         changeKeyboardType(KEYBOARD_12KEY);
1028                         mHookStockKeyType = KEYBOARD_12KEY;
1029                         break;
1030
1031                 case KEYCODE_JP12_KBD:
1032                         changeKeyboardType(KEYBOARD_QWERTY);
1033                         mHookStockKeyType = KEYBOARD_QWERTY;
1034                         break;
1035
1036                 case KEYCODE_JP12_EMOJI:
1037                 case KEYCODE_QWERTY_EMOJI:
1038                         commitText();
1039                         mWnn.onEvent(mEventChangeModeSymbol);
1040                         break;
1041
1042                 case KEYCODE_JP12_1:
1043                 case KEYCODE_JP12_2:
1044                 case KEYCODE_JP12_3:
1045                 case KEYCODE_JP12_4:
1046                 case KEYCODE_JP12_5:
1047                 case KEYCODE_JP12_6:
1048                 case KEYCODE_JP12_7:
1049                 case KEYCODE_JP12_8:
1050                 case KEYCODE_JP12_9:
1051                 case KEYCODE_JP12_0:
1052                 case KEYCODE_JP12_SHARP:
1053                         /* Processing to input by ten key */
1054                         if (mInputType == INPUT_TYPE_INSTANT) {
1055                                 /* Send a input character directly if instant input type is selected */
1056                                 commitText();
1057                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, mCurrentInstantTable[getTableIndex(primaryCode)]));
1058                         } else {
1059                                 if ((mPrevInputKeyCode != primaryCode)) {
1060                                         mWnn.onEvent(mEventTouchOtherKey);
1061                                         if ((mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)
1062                                             && (primaryCode == KEYCODE_JP12_SHARP)) {
1063                                                 /* Commit text by symbol character (',' '.') when alphabet input mode is selected */
1064                                                 commitText();
1065                                         }
1066                                 }
1067
1068                                 /* Convert the key code to the table index and send the toggle event with the table index */
1069                                 String[][] cycleTable = getCycleTable();
1070                                 if (cycleTable == null) {
1071                                         Log.e("NicoWnn", "not founds cycle table");
1072                                 } else {
1073                                         int index = getTableIndex(primaryCode);
1074                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[index]));
1075                                         mCurrentCycleTable = cycleTable[index];
1076                                 }
1077                                 mPrevInputKeyCode = primaryCode;
1078                         }
1079                         break;
1080
1081                 case KEYCODE_JP12_ASTER:
1082                         if (mInputType == INPUT_TYPE_INSTANT) {
1083                                 commitText();
1084                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, mCurrentInstantTable[getTableIndex(primaryCode)]));
1085                         } else {
1086                                 if (!mNoInput) {
1087                                         /* Processing to toggle Dakuten, Handakuten, and capital */
1088                                         HashMap<String,String> replaceTable = getReplaceTable();
1089                                         if (replaceTable == null) {
1090                                                 Log.e("NicoWnn", "not founds replace table");
1091                                         } else {
1092                                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.REPLACE_CHAR, replaceTable));
1093                                                 mPrevInputKeyCode = primaryCode;
1094                                         }
1095                                 }
1096                         }
1097                         break;
1098
1099                 case KEYCODE_SWITCH_FULL_ALPHABET:
1100                         /* Change mode to Full width alphabet */
1101                         changeKeyMode(KEYMODE_JA_FULL_ALPHABET);
1102                         break;
1103
1104                 case KEYCODE_SWITCH_FULL_NUMBER:
1105                         /* Change mode to Full width numeric */
1106                         changeKeyMode(KEYMODE_JA_FULL_NUMBER);
1107                         break;
1108
1109                 case KEYCODE_SWITCH_HALF_ALPHABET:
1110                         /* Change mode to Half width alphabet */
1111                         changeKeyMode(KEYMODE_JA_HALF_ALPHABET);
1112                         break;
1113
1114                 case KEYCODE_SWITCH_HALF_NUMBER:
1115                         /* Change mode to Half width numeric */
1116                         changeKeyMode(KEYMODE_JA_HALF_NUMBER);
1117                         break;
1118
1119                 case KEYCODE_SWITCH_FULL_NICO:
1120                         /* Change mode to Full width nicotouch */
1121                         changeKeyMode(KEYMODE_JA_FULL_NICO);
1122                         break;
1123
1124                 case KEYCODE_SELECT_CASE:
1125                         int shifted = (mShiftOn == 0) ? 1 : 0;
1126                         Keyboard newKeyboard = getShiftChangeKeyboard(shifted);
1127                         if (newKeyboard != null) {
1128                                 mShiftOn = shifted;
1129                                 changeKeyboard(newKeyboard);
1130                         }
1131                         break;
1132
1133                 case KEYCODE_JP12_SPACE:
1134                         if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) {
1135                                 mWnn.onEvent(mEventConvert);
1136                         } else {
1137                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, ' '));
1138                         }
1139                         break;
1140
1141                 case KEYCODE_EISU_KANA:
1142                         mWnn.onEvent(mEventChangeModeEisuKana);
1143                         break;
1144
1145                 case KEYCODE_JP12_CLOSE:
1146                         mWnn.onEvent(mEventInputBack);
1147                         break;
1148
1149                 case KEYCODE_JP12_LEFT:
1150                         mWnn.onEvent(mEventInputDpadLeft);
1151                         break;
1152
1153                 case KEYCODE_JP12_RIGHT:
1154                         mWnn.onEvent(mEventInputDpadRight);
1155                         break;
1156                 case KEYCODE_NOP:
1157                         break;
1158
1159                 default:
1160                         if (primaryCode >= 0) {
1161                                 if (mKeyboardView.isShifted()) {
1162                                         primaryCode = Character.toUpperCase(primaryCode);
1163                                 }
1164                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, (char)primaryCode));
1165                         }
1166                         break;
1167                 }
1168
1169                 /* update shift key's state */
1170                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
1171                         setShiftByEditorInfo();
1172                 }
1173         }
1174
1175
1176         /*****************************************
1177          * onkey nicotouch
1178          */
1179         private boolean onKeyNico(int primaryCode, int[] keyCodes) {
1180                 Keyboard newKeyboard = null;
1181                 boolean retcode = false;
1182
1183                 //Log.v("key", "onkey event!!\n");
1184
1185                 switch (primaryCode) {
1186                 case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE:
1187                 case KEYCODE_JP12_BACKSPACE:
1188                         if (mNicoFirst == true) {
1189                                 resetNicoKeyboard();
1190                         }
1191                         else {
1192                                 mWnn.onEvent(mEventInputKeyDel);
1193                         }
1194                         retcode = true;
1195                         break;
1196                 case KEYCODE_QWERTY_ENTER:
1197                 case KEYCODE_JP12_ENTER:
1198                         if (mNicoFirst == false) {
1199                                 mWnn.onEvent(mEventInputEnter);
1200                         }
1201                         retcode = true;
1202                         break;
1203
1204                 case KEYCODE_JP12_REVERSE:
1205                         if (mNicoFirst == true) {
1206                                 resetNicoKeyboard();
1207                         }
1208                         //mWnn.mushup();
1209                         retcode = true;
1210                         break;
1211
1212                 case KEYCODE_QWERTY_KBD:
1213                 case KEYCODE_JP12_KBD:
1214                         resetNicoKeyboard();
1215                         break;
1216
1217                 case KEYCODE_JP12_EMOJI:
1218                 case KEYCODE_QWERTY_EMOJI:
1219                         if (mNicoFirst == false) {
1220                                 commitText();
1221                                 mWnn.onEvent(mEventChangeModeSymbol);
1222                         }
1223                         retcode = true;
1224                         break;
1225
1226                 case KEYCODE_JP12_SHARP:
1227                         if (mNicoFirst == false && mNoInput) {
1228                                 commitText();
1229                                 mWnn.onEvent(mEventChangeModeDocomo);
1230                         }
1231                         retcode = true;
1232                         break;
1233
1234                 case KEYCODE_JP12_1:
1235                 case KEYCODE_JP12_2:
1236                 case KEYCODE_JP12_3:
1237                 case KEYCODE_JP12_4:
1238                 case KEYCODE_JP12_5:
1239                 case KEYCODE_JP12_6:
1240                 case KEYCODE_JP12_7:
1241                 case KEYCODE_JP12_8:
1242                 case KEYCODE_JP12_9:
1243                 case KEYCODE_JP12_0:
1244                         if ((NICOFLICK_1STROKE == mFlickNicoInput) && (false == mNicoFirst)) {
1245                                 retcode = true;
1246                                 break;
1247                         }
1248                         if ((NICOFLICK_NICOSTROKE == mFlickNicoInput) && (true == mNicoFlick) && (mPrevInputKeyCode == primaryCode)) {
1249                                 mNicoFlick = false;
1250                                 retcode = true;
1251                                 break;
1252                         }
1253                         if (mNicoFirst == false) {
1254                                 mWnn.onEvent(mEventTouchOtherKey);
1255                                 mPrevInputKeyCode = primaryCode;
1256                                 mNicoFirst = true;
1257
1258                                 /* change keymap */
1259                                 int index = getTableIndex(primaryCode);
1260                                 Keyboard[][] keyList = mKeyboard[LANG_JA][mDisplayMode][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
1261
1262                                 keyList[KEYMODE_JA_FULL_NICO] = mNicoKeyboard[index+1];
1263                                 if (false == mNoFlipScreen) {
1264                                         newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_ON);
1265                                         mShiftOn = KEYBOARD_SHIFT_ON;
1266                                         changeKeyboard(newKeyboard);
1267                                 }
1268                         }
1269                         else{
1270                                 int col = getTableIndex(mPrevInputKeyCode);
1271                                 int row = getTableIndex(primaryCode);
1272                                 String[][] cycleTable = getCycleTable();
1273                                 if (cycleTable == null) {
1274                                         Log.e("NicoWnn", "not founds cycle table");
1275                                 }
1276                                 else{
1277                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[col * 10 + row]));
1278                                 }
1279                                 mNicoFirst = false;
1280                                 mNicoFlick = false;
1281                                 if (false == mNoFlipScreen) {
1282                                         newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_OFF);
1283                                         mShiftOn = KEYBOARD_SHIFT_OFF;
1284                                         changeKeyboard(newKeyboard);
1285                                 }
1286                         }
1287                         retcode = true;
1288                         break;
1289
1290                 case KEYCODE_JP12_ASTER:
1291                         if (mNicoFirst == true) {
1292                                 resetNicoKeyboard();
1293                         }
1294                         if (mNicoFirst == false && !mNoInput) {
1295                                 /* Processing to toggle Dakuten, Handakuten, and capital */
1296                                 HashMap<String,String> replaceTable = getReplaceTable();
1297                                 if (replaceTable == null) {
1298                                         Log.e("NicoWnn", "not founds replace table");
1299                                 } else {
1300                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.REPLACE_CHAR, replaceTable));
1301                                         mPrevInputKeyCode = primaryCode;
1302                                 }
1303                         }
1304                         retcode = true;
1305                         break;
1306
1307                 case KEYCODE_JP12_SPACE:
1308                         if (mNicoFirst == false) {
1309                                 if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) {
1310                                         mWnn.onEvent(mEventConvert);
1311                                 } else {
1312                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, ' '));
1313                                 }
1314                         }
1315                         retcode = true;
1316                         break;
1317
1318                 case KEYCODE_EISU_KANA:
1319                         if (mNicoFirst == false) {
1320                                 mWnn.onEvent(mEventChangeModeEisuKana);
1321                         }
1322                         retcode = true;
1323                         break;
1324
1325                 case KEYCODE_JP12_CLOSE:
1326                         mWnn.onEvent(mEventInputBack);
1327                         retcode = true;
1328                         break;
1329
1330                 case KEYCODE_JP12_LEFT:
1331                         if (mNicoFirst == false) {
1332                                 mWnn.onEvent(mEventInputDpadLeft);
1333                         }
1334                         retcode = true;
1335                         break;
1336                 case KEYCODE_JP12_RIGHT:
1337                         if (mNicoFirst == false) {
1338                                 mWnn.onEvent(mEventInputDpadRight);
1339                         }
1340                         retcode = true;
1341                         break;
1342                 }
1343                 return retcode;
1344         } // onKeyNico
1345         /*
1346          * reset nicotouch keyboard
1347          */
1348         @Override public void resetNicoKeyboard() {
1349                 Keyboard newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_OFF);
1350                 if (newKeyboard != null) {
1351                         mShiftOn = KEYBOARD_SHIFT_OFF;
1352                         changeKeyboard(newKeyboard);
1353                 }
1354                 mNicoFirst = false;
1355                 mNicoFlick = false;
1356         } // resetNicoKeyboard
1357
1358         /**
1359          */
1360         @Override public void onPress(int primaryCode) {
1361                 super.onPress(primaryCode);
1362                 Keyboard newKeyboard = null;
1363
1364                 mStockFlickCode = primaryCode;
1365                 if (mCurrentKeyMode == KEYMODE_JA_FULL_NICO) {
1366                         if (NICOFLICK_NONE == mFlickNicoInput) {
1367                                 return;
1368                         }
1369                         switch (primaryCode) {
1370                         case KEYCODE_JP12_1:
1371                         case KEYCODE_JP12_2:
1372                         case KEYCODE_JP12_3:
1373                         case KEYCODE_JP12_4:
1374                         case KEYCODE_JP12_5:
1375                         case KEYCODE_JP12_6:
1376                         case KEYCODE_JP12_7:
1377                         case KEYCODE_JP12_8:
1378                         case KEYCODE_JP12_9:
1379                         case KEYCODE_JP12_0:
1380                                 if ((false == mNicoFirst) && (false == mNicoFlick)) {
1381                                         mWnn.onEvent(mEventTouchOtherKey);
1382                                         if (false == mNoFlipScreen) {
1383                                                 /* change keymap */
1384                                                 int index = getTableIndex(primaryCode);
1385                                                 Keyboard[][] keyList = mKeyboard[LANG_JA][mDisplayMode][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
1386                                                 keyList[KEYMODE_JA_FULL_NICO] = mNicoKeyboard[index+1];
1387                                                 newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_ON);
1388                                                 if (newKeyboard != null) {
1389                                                         mShiftOn = KEYBOARD_SHIFT_ON;
1390                                                         changeKeyboard(newKeyboard);
1391                                                 }
1392                                         }
1393                                         mPrevInputKeyCode = primaryCode;
1394                                         mNicoFirst = true;
1395                                         mNicoFlick = true;
1396                                 }
1397                                 break;
1398                         }
1399                 }
1400         }
1401         /**
1402          */
1403         @Override public void onRelease(int primaryCode) {
1404                 super.onRelease(primaryCode);
1405         } // onRelease
1406
1407 }