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