src/com/hiroshica/android/input/nicownn2/JAJP/DefaultSoftKeyboardJAJP.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
  17 package com.hiroshica.android.input.nicownn2.JAJP;
  18
  19 import android.view.KeyEvent;
  20 import android.view.inputmethod.EditorInfo;
  21 import android.view.inputmethod.InputConnection;
  22 import android.inputmethodservice.Keyboard;
  23 import android.util.Log;
  24 import android.view.View;
  25 import android.content.SharedPreferences;
  26 import android.content.Intent;
  27 import android.os.*;
  28 import android.app.Activity;
  29
  30 import android.inputmethodservice.InputMethodService;
  31 import android.view.WindowManager;
  32 import android.content.Context;
  33 import android.view.View;
  34 import android.view.KeyEvent;
  35 import android.content.SharedPreferences;
  36 import android.preference.PreferenceManager;
  37 import android.content.pm.PackageManager;
  38 import android.util.Log;
  39 import android.os.*;
  40 import android.view.inputmethod.*;
  41 import android.content.res.Configuration;
  42 import android.graphics.*;
  43 import android.graphics.drawable.*;
  44 import android.view.MotionEvent;
  45 import android.app.Activity;
  46 import android.content.Intent;
  47
  48
  49 import java.lang.Object;
  50 import java.util.HashMap;
  51 import java.util.Locale;
  52 import java.util.List;
  53 import java.lang.Math;
  54
  55 import com.hiroshica.android.input.nicownn2.*;
  56
  57 /**
  58  * The default Software Keyboard class for Japanese IME.
  59  *
  60  * @author Copyright (C) 2009 OMRON SOFTWARE CO., LTD.  All Rights Reserved.
  61  */
  62 public class DefaultSoftKeyboardJAJP extends DefaultSoftKeyboard {
  63         private static final String GETACTION_INTERCEPT = "com.hiroshica.android.input.nicownn2.ACTION_INTERCEPT";
  64         private static final String REPLACE_KEY = "replace_key";
  65         private static final String INPUTCONNECTION_KEY = "inputconnection_key";
  66
  67         /** Enable English word prediction on half-width alphabet mode */
  68         private static final boolean USE_ENGLISH_PREDICT = true;
  69
  70         /** Key code for switching to full-width HIRAGANA mode */
  71         private static final int KEYCODE_SWITCH_FULL_HIRAGANA = -301;
  72
  73         /** Key code for switching to full-width KATAKANA mode */
  74         private static final int KEYCODE_SWITCH_FULL_KATAKANA = -302;
  75
  76         /** Key code for switching to full-width alphabet mode */
  77         private static final int KEYCODE_SWITCH_FULL_ALPHABET = -303;
  78
  79         /** Key code for switching to full-width number mode */
  80         private static final int KEYCODE_SWITCH_FULL_NUMBER = -304;
  81
  82         /** Key code for switching to half-width KATAKANA mode */
  83         private static final int KEYCODE_SWITCH_HALF_KATAKANA = -306;
  84
  85         /** Key code for switching to half-width alphabet mode */
  86         private static final int KEYCODE_SWITCH_HALF_ALPHABET = -307;
  87
  88         /** Key code for switching to half-width number mode */
  89         private static final int KEYCODE_SWITCH_HALF_NUMBER = -308;
  90
  91         /** Key code for case toggle key */
  92         private static final int KEYCODE_SELECT_CASE = -309;
  93
  94         /** Key code for EISU-KANA conversion */
  95         private static final int KEYCODE_EISU_KANA = -305;
  96
  97         /** Key code for switching to full-width Nikotouch mode */
  98         private static final int KEYCODE_SWITCH_FULL_NIKO = -400;
  99
 100         /** Key code for NOP (no-operation) */
 101         private static final int KEYCODE_NOP = -310;
 102
 103
 104         /** Input mode toggle cycle table */
 105         private static final int[] JP_MODE_CYCLE_TABLE = {
 106                 KEYMODE_JA_FULL_NIKO, KEYMODE_JA_FULL_HIRAGANA, KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER,
 107         };
 108
 109         /** Definition for {@code mInputType} (toggle) */
 110         private static final int INPUT_TYPE_TOGGLE = 1;
 111
 112         /** Definition for {@code mInputType} (commit instantly) */
 113         private static final int INPUT_TYPE_INSTANT = 2;
 114
 115         /** Max key number of the 12 key keyboard (depends on the definition of keyboards) */
 116         private static final int KEY_NUMBER_12KEY = 20;
 117
 118         /** Toggle cycle table for full-width HIRAGANA */
 119         private static final String[][] JP_FULL_HIRAGANA_CYCLE_TABLE = {
 120                 {"\u3042", "\u3044", "\u3046", "\u3048", "\u304a", "\u3041", "\u3043", "\u3045", "\u3047", "\u3049"},
 121                 {"\u304b", "\u304d", "\u304f", "\u3051", "\u3053"},
 122                 {"\u3055", "\u3057", "\u3059", "\u305b", "\u305d"},
 123                 {"\u305f", "\u3061", "\u3064", "\u3066", "\u3068", "\u3063"},
 124                 {"\u306a", "\u306b", "\u306c", "\u306d", "\u306e"},
 125                 {"\u306f", "\u3072", "\u3075", "\u3078", "\u307b"},
 126                 {"\u307e", "\u307f", "\u3080", "\u3081", "\u3082"},
 127                 {"\u3084", "\u3086", "\u3088", "\u3083", "\u3085", "\u3087"},
 128                 {"\u3089", "\u308a", "\u308b", "\u308c", "\u308d"},
 129                 {"\u308f", "\u3092", "\u3093", "\u308e", "\u30fc"},
 130                 {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"},
 131         };
 132
 133         /** Replace table for full-width HIRAGANA */
 134         private static final HashMap<String, String> JP_FULL_HIRAGANA_REPLACE_TABLE = new HashMap<String, String>() {{
 135                         put("\u3042", "\u3041"); put("\u3044", "\u3043"); put("\u3046", "\u3045"); put("\u3048", "\u3047"); put("\u304a", "\u3049");
 136                         put("\u3041", "\u3042"); put("\u3043", "\u3044"); put("\u3045", "\u30f4"); put("\u3047", "\u3048"); put("\u3049", "\u304a");
 137                         put("\u304b", "\u304c"); put("\u304d", "\u304e"); put("\u304f", "\u3050"); put("\u3051", "\u3052"); put("\u3053", "\u3054");
 138                         put("\u304c", "\u304b"); put("\u304e", "\u304d"); put("\u3050", "\u304f"); put("\u3052", "\u3051"); put("\u3054", "\u3053");
 139                         put("\u3055", "\u3056"); put("\u3057", "\u3058"); put("\u3059", "\u305a"); put("\u305b", "\u305c"); put("\u305d", "\u305e");
 140                         put("\u3056", "\u3055"); put("\u3058", "\u3057"); put("\u305a", "\u3059"); put("\u305c", "\u305b"); put("\u305e", "\u305d");
 141                         put("\u305f", "\u3060"); put("\u3061", "\u3062"); put("\u3064", "\u3063"); put("\u3066", "\u3067"); put("\u3068", "\u3069");
 142                         put("\u3060", "\u305f"); put("\u3062", "\u3061"); put("\u3063", "\u3065"); put("\u3067", "\u3066"); put("\u3069", "\u3068");
 143                         put("\u3065", "\u3064"); put("\u30f4", "\u3046");
 144                         put("\u306f", "\u3070"); put("\u3072", "\u3073"); put("\u3075", "\u3076"); put("\u3078", "\u3079"); put("\u307b", "\u307c");
 145                         put("\u3070", "\u3071"); put("\u3073", "\u3074"); put("\u3076", "\u3077"); put("\u3079", "\u307a"); put("\u307c", "\u307d");
 146                         put("\u3071", "\u306f"); put("\u3074", "\u3072"); put("\u3077", "\u3075"); put("\u307a", "\u3078"); put("\u307d", "\u307b");
 147                         put("\u3084", "\u3083"); put("\u3086", "\u3085"); put("\u3088", "\u3087");
 148                         put("\u3083", "\u3084"); put("\u3085", "\u3086"); put("\u3087", "\u3088");
 149                         put("\u308f", "\u308e");
 150                         put("\u308e", "\u308f");
 151                         put("\u309b", "\u309c");
 152                         put("\u309c", "\u309b");
 153                 }};
 154
 155         /** Toggle cycle table for full-width KATAKANA */
 156         private static final String[][] JP_FULL_KATAKANA_CYCLE_TABLE = {
 157                 {"\u30a2", "\u30a4", "\u30a6", "\u30a8", "\u30aa", "\u30a1", "\u30a3",
 158                  "\u30a5", "\u30a7", "\u30a9"},
 159                 {"\u30ab", "\u30ad", "\u30af", "\u30b1", "\u30b3"},
 160                 {"\u30b5", "\u30b7", "\u30b9", "\u30bb", "\u30bd"},
 161                 {"\u30bf", "\u30c1", "\u30c4", "\u30c6", "\u30c8", "\u30c3"},
 162                 {"\u30ca", "\u30cb", "\u30cc", "\u30cd", "\u30ce"},
 163                 {"\u30cf", "\u30d2", "\u30d5", "\u30d8", "\u30db"},
 164                 {"\u30de", "\u30df", "\u30e0", "\u30e1", "\u30e2"},
 165                 {"\u30e4", "\u30e6", "\u30e8", "\u30e3", "\u30e5", "\u30e7"},
 166                 {"\u30e9", "\u30ea", "\u30eb", "\u30ec", "\u30ed"},
 167                 {"\u30ef", "\u30f2", "\u30f3", "\u30ee", "\u30fc"},
 168                 {"\u3001", "\u3002", "\uff1f", "\uff01", "\u30fb", "\u3000"}
 169         };
 170
 171         /** Replace table for full-width KATAKANA */
 172         private static final HashMap<String,String> JP_FULL_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{
 173                         put("\u30a2", "\u30a1"); put("\u30a4", "\u30a3"); put("\u30a6", "\u30a5"); put("\u30a8", "\u30a7"); put("\u30aa", "\u30a9");
 174                         put("\u30a1", "\u30a2"); put("\u30a3", "\u30a4"); put("\u30a5", "\u30f4"); put("\u30a7", "\u30a8"); put("\u30a9", "\u30aa");
 175                         put("\u30ab", "\u30ac"); put("\u30ad", "\u30ae"); put("\u30af", "\u30b0"); put("\u30b1", "\u30b2"); put("\u30b3", "\u30b4");
 176                         put("\u30ac", "\u30ab"); put("\u30ae", "\u30ad"); put("\u30b0", "\u30af"); put("\u30b2", "\u30b1"); put("\u30b4", "\u30b3");
 177                         put("\u30b5", "\u30b6"); put("\u30b7", "\u30b8"); put("\u30b9", "\u30ba"); put("\u30bb", "\u30bc"); put("\u30bd", "\u30be");
 178                         put("\u30b6", "\u30b5"); put("\u30b8", "\u30b7"); put("\u30ba", "\u30b9"); put("\u30bc", "\u30bb"); put("\u30be", "\u30bd");
 179                         put("\u30bf", "\u30c0"); put("\u30c1", "\u30c2"); put("\u30c4", "\u30c3"); put("\u30c6", "\u30c7"); put("\u30c8", "\u30c9");
 180                         put("\u30c0", "\u30bf"); put("\u30c2", "\u30c1"); put("\u30c3", "\u30c5"); put("\u30c7", "\u30c6"); put("\u30c9", "\u30c8");
 181                         put("\u30c5", "\u30c4"); put("\u30f4", "\u30a6");
 182                         put("\u30cf", "\u30d0"); put("\u30d2", "\u30d3"); put("\u30d5", "\u30d6"); put("\u30d8", "\u30d9"); put("\u30db", "\u30dc");
 183                         put("\u30d0", "\u30d1"); put("\u30d3", "\u30d4"); put("\u30d6", "\u30d7"); put("\u30d9", "\u30da"); put("\u30dc", "\u30dd");
 184                         put("\u30d1", "\u30cf"); put("\u30d4", "\u30d2"); put("\u30d7", "\u30d5"); put("\u30da", "\u30d8"); put("\u30dd", "\u30db");
 185                         put("\u30e4", "\u30e3"); put("\u30e6", "\u30e5"); put("\u30e8", "\u30e7");
 186                         put("\u30e3", "\u30e4"); put("\u30e5", "\u30e6"); put("\u30e7", "\u30e8");
 187                         put("\u30ef", "\u30ee");
 188                         put("\u30ee", "\u30ef");
 189                 }};
 190
 191         /** Toggle cycle table for half-width KATAKANA */
 192         private static final String[][] JP_HALF_KATAKANA_CYCLE_TABLE = {
 193                 {"\uff71", "\uff72", "\uff73", "\uff74", "\uff75", "\uff67", "\uff68", "\uff69", "\uff6a", "\uff6b"},
 194                 {"\uff76", "\uff77", "\uff78", "\uff79", "\uff7a"},
 195                 {"\uff7b", "\uff7c", "\uff7d", "\uff7e", "\uff7f"},
 196                 {"\uff80", "\uff81", "\uff82", "\uff83", "\uff84", "\uff6f"},
 197                 {"\uff85", "\uff86", "\uff87", "\uff88", "\uff89"},
 198                 {"\uff8a", "\uff8b", "\uff8c", "\uff8d", "\uff8e"},
 199                 {"\uff8f", "\uff90", "\uff91", "\uff92", "\uff93"},
 200                 {"\uff94", "\uff95", "\uff96", "\uff6c", "\uff6d", "\uff6e"},
 201                 {"\uff97", "\uff98", "\uff99", "\uff9a", "\uff9b"},
 202                 {"\uff9c", "\uff66", "\uff9d", "\uff70"},
 203                 {"\uff64", "\uff61", "?", "!", "\uff65", " "},
 204         };
 205
 206         /** Replace table for half-width KATAKANA */
 207         private static final HashMap<String,String> JP_HALF_KATAKANA_REPLACE_TABLE = new HashMap<String,String>() {{
 208                         put("\uff71", "\uff67");  put("\uff72", "\uff68");  put("\uff73", "\uff69");  put("\uff74", "\uff6a");  put("\uff75", "\uff6b");
 209                         put("\uff67", "\uff71");  put("\uff68", "\uff72");  put("\uff69", "\uff73\uff9e");  put("\uff6a", "\uff74");  put("\uff6b", "\uff75");
 210                         put("\uff76", "\uff76\uff9e"); put("\uff77", "\uff77\uff9e"); put("\uff78", "\uff78\uff9e"); put("\uff79", "\uff79\uff9e"); put("\uff7a", "\uff7a\uff9e");
 211                         put("\uff76\uff9e", "\uff76"); put("\uff77\uff9e", "\uff77"); put("\uff78\uff9e", "\uff78"); put("\uff79\uff9e", "\uff79"); put("\uff7a\uff9e", "\uff7a");
 212                         put("\uff7b", "\uff7b\uff9e"); put("\uff7c", "\uff7c\uff9e"); put("\uff7d", "\uff7d\uff9e"); put("\uff7e", "\uff7e\uff9e"); put("\uff7f", "\uff7f\uff9e");
 213                         put("\uff7b\uff9e", "\uff7b"); put("\uff7c\uff9e", "\uff7c"); put("\uff7d\uff9e", "\uff7d"); put("\uff7e\uff9e", "\uff7e"); put("\uff7f\uff9e", "\uff7f");
 214                         put("\uff80", "\uff80\uff9e"); put("\uff81", "\uff81\uff9e"); put("\uff82", "\uff6f");  put("\uff83", "\uff83\uff9e"); put("\uff84", "\uff84\uff9e");
 215                         put("\uff80\uff9e", "\uff80"); put("\uff81\uff9e", "\uff81"); put("\uff6f", "\uff82\uff9e"); put("\uff83\uff9e", "\uff83"); put("\uff84\uff9e", "\uff84");
 216                         put("\uff82\uff9e", "\uff82");
 217                         put("\uff8a", "\uff8a\uff9e"); put("\uff8b", "\uff8b\uff9e"); put("\uff8c", "\uff8c\uff9e"); put("\uff8d", "\uff8d\uff9e"); put("\uff8e", "\uff8e\uff9e");
 218                         put("\uff8a\uff9e", "\uff8a\uff9f");put("\uff8b\uff9e", "\uff8b\uff9f");put("\uff8c\uff9e", "\uff8c\uff9f");put("\uff8d\uff9e", "\uff8d\uff9f");put("\uff8e\uff9e", "\uff8e\uff9f");
 219                         put("\uff8a\uff9f", "\uff8a"); put("\uff8b\uff9f", "\uff8b"); put("\uff8c\uff9f", "\uff8c"); put("\uff8d\uff9f", "\uff8d"); put("\uff8e\uff9f", "\uff8e");
 220                         put("\uff94", "\uff6c");  put("\uff95", "\uff6d");  put("\uff96", "\uff6e");
 221                         put("\uff6c", "\uff94");  put("\uff6d", "\uff95");  put("\uff6e", "\uff96");
 222                         put("\uff9c", "\uff9c"); put("\uff73\uff9e", "\uff73");
 223                 }};
 224
 225         /** Toggle cycle table for full-width alphabet */
 226         private static final String[][] JP_FULL_ALPHABET_CYCLE_TABLE = {
 227                 {"\uff0e", "\uff20", "\uff0d", "\uff3f", "\uff0f", "\uff1a", "\uff5e", "\uff11"},
 228                 {"\uff41", "\uff42", "\uff43", "\uff21", "\uff22", "\uff23", "\uff12"},
 229                 {"\uff44", "\uff45", "\uff46", "\uff24", "\uff25", "\uff26", "\uff13"},
 230                 {"\uff47", "\uff48", "\uff49", "\uff27", "\uff28", "\uff29", "\uff14"},
 231                 {"\uff4a", "\uff4b", "\uff4c", "\uff2a", "\uff2b", "\uff2c", "\uff15"},
 232                 {"\uff4d", "\uff4e", "\uff4f", "\uff2d", "\uff2e", "\uff2f", "\uff16"},
 233                 {"\uff50", "\uff51", "\uff52", "\uff53", "\uff30", "\uff31", "\uff32", "\uff33", "\uff17"},
 234                 {"\uff54", "\uff55", "\uff56", "\uff34", "\uff35", "\uff36", "\uff18"},
 235                 {"\uff57", "\uff58", "\uff59", "\uff5a", "\uff37", "\uff38", "\uff39", "\uff3a", "\uff19"},
 236                 {"\uff0d", "\uff10"},
 237                 {"\uff0c", "\uff0e", "\uff1f", "\uff01", "\u30fb", "\u3000"}
 238         };
 239
 240         /** Replace table for full-width alphabet */
 241         private static final HashMap<String,String> JP_FULL_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{
 242                         put("\uff21", "\uff41"); put("\uff22", "\uff42"); put("\uff23", "\uff43"); put("\uff24", "\uff44"); put("\uff25", "\uff45");
 243                         put("\uff41", "\uff21"); put("\uff42", "\uff22"); put("\uff43", "\uff23"); put("\uff44", "\uff24"); put("\uff45", "\uff25");
 244                         put("\uff26", "\uff46"); put("\uff27", "\uff47"); put("\uff28", "\uff48"); put("\uff29", "\uff49"); put("\uff2a", "\uff4a");
 245                         put("\uff46", "\uff26"); put("\uff47", "\uff27"); put("\uff48", "\uff28"); put("\uff49", "\uff29"); put("\uff4a", "\uff2a");
 246                         put("\uff2b", "\uff4b"); put("\uff2c", "\uff4c"); put("\uff2d", "\uff4d"); put("\uff2e", "\uff4e"); put("\uff2f", "\uff4f");
 247                         put("\uff4b", "\uff2b"); put("\uff4c", "\uff2c"); put("\uff4d", "\uff2d"); put("\uff4e", "\uff2e"); put("\uff4f", "\uff2f");
 248                         put("\uff30", "\uff50"); put("\uff31", "\uff51"); put("\uff32", "\uff52"); put("\uff33", "\uff53"); put("\uff34", "\uff54");
 249                         put("\uff50", "\uff30"); put("\uff51", "\uff31"); put("\uff52", "\uff32"); put("\uff53", "\uff33"); put("\uff54", "\uff34");
 250                         put("\uff35", "\uff55"); put("\uff36", "\uff56"); put("\uff37", "\uff57"); put("\uff38", "\uff58"); put("\uff39", "\uff59");
 251                         put("\uff55", "\uff35"); put("\uff56", "\uff36"); put("\uff57", "\uff37"); put("\uff58", "\uff38"); put("\uff59", "\uff39");
 252                         put("\uff3a", "\uff5a");
 253                         put("\uff5a", "\uff3a");
 254                 }};
 255
 256         /** Toggle cycle table for half-width alphabet */
 257         private static final String[][] JP_HALF_ALPHABET_CYCLE_TABLE = {
 258                 {".", "@", "-", "_", "/", ":", "~", "1"},
 259                 {"a", "b", "c", "A", "B", "C", "2"},
 260                 {"d", "e", "f", "D", "E", "F", "3"},
 261                 {"g", "h", "i", "G", "H", "I", "4"},
 262                 {"j", "k", "l", "J", "K", "L", "5"},
 263                 {"m", "n", "o", "M", "N", "O", "6"},
 264                 {"p", "q", "r", "s", "P", "Q", "R", "S", "7"},
 265                 {"t", "u", "v", "T", "U", "V", "8"},
 266                 {"w", "x", "y", "z", "W", "X", "Y", "Z", "9"},
 267                 {"-", "0"},
 268                 {",", ".", "?", "!", ";", " "}
 269         };
 270
 271         /** Replace table for half-width alphabet */
 272         private static final HashMap<String,String> JP_HALF_ALPHABET_REPLACE_TABLE = new HashMap<String,String>() {{
 273                         put("A", "a"); put("B", "b"); put("C", "c"); put("D", "d"); put("E", "e");
 274                         put("a", "A"); put("b", "B"); put("c", "C"); put("d", "D"); put("e", "E");
 275                         put("F", "f"); put("G", "g"); put("H", "h"); put("I", "i"); put("J", "j");
 276                         put("f", "F"); put("g", "G"); put("h", "H"); put("i", "I"); put("j", "J");
 277                         put("K", "k"); put("L", "l"); put("M", "m"); put("N", "n"); put("O", "o");
 278                         put("k", "K"); put("l", "L"); put("m", "M"); put("n", "N"); put("o", "O");
 279                         put("P", "p"); put("Q", "q"); put("R", "r"); put("S", "s"); put("T", "t");
 280                         put("p", "P"); put("q", "Q"); put("r", "R"); put("s", "S"); put("t", "T");
 281                         put("U", "u"); put("V", "v"); put("W", "w"); put("X", "x"); put("Y", "y");
 282                         put("u", "U"); put("v", "V"); put("w", "W"); put("x", "X"); put("y", "Y");
 283                         put("Z", "z");
 284                         put("z", "Z");
 285                 }};
 286
 287         /** Toggle cycle table for full-width Nikotouch */
 288         private static final String[][] JP_FULL_NIKO_CYCLE_TABLE = {
 289                 {"\u3042"}, {"\u3044"}, {"\u3046"}, {"\u3048"}, {"\u304a"},      {"."},      {"-"},      {"@"},      {"_"}, {"1"},
 290                 {"\u304b"}, {"\u304d"}, {"\u304f"}, {"\u3051"}, {"\u3053"},      {" "},      {"a"},      {"b"},      {"c"}, {"2"},
 291                 {"\u3055"}, {"\u3057"}, {"\u3059"}, {"\u305b"}, {"\u305d"},      {"/"},      {"d"},      {"e"},      {"f"}, {"3"},
 292                 {"\u305f"}, {"\u3061"}, {"\u3064"}, {"\u3066"}, {"\u3068"}, {"\u3063"},      {"g"},      {"h"},      {"i"}, {"4"},
 293                 {"\u306a"}, {"\u306b"}, {"\u306c"}, {"\u306d"}, {"\u306e"},      {"("},      {"j"},      {"k"},      {"l"}, {"5"},
 294                 {"\u306f"}, {"\u3072"}, {"\u3075"}, {"\u3078"}, {"\u307b"},      {")"},      {"m"},      {"n"},      {"o"}, {"6"},
 295                 {"\u307e"}, {"\u307f"}, {"\u3080"}, {"\u3081"}, {"\u3082"},      {"p"},      {"q"},      {"r"},      {"s"}, {"7"},
 296                 {"\u3084"}, {"\u3086"}, {"\u3088"}, {"\u3083"}, {"\u3085"}, {"\u3087"},      {"t"},      {"u"},      {"v"}, {"8"},
 297                 {"\u3089"}, {"\u308a"}, {"\u308b"}, {"\u308c"}, {"\u308d"},      {"w"},      {"x"},      {"y"},      {"z"}, {"9"},
 298                 {"\u308f"}, {"\u3092"}, {"\u3093"}, {"\u3001"}, {"\u3002"}, {"\u30fc"}, {"\u30fb"}, {"\uff01"}, {"\uff1f"}, {"0"},
 299         };
 300
 301         /** Replace table for full-width Nikotouch */
 302         private static final HashMap<String, String> JP_FULL_NIKO_REPLACE_TABLE = new HashMap<String, String>() {{
 303                         put("\u3042", "\u3041"); put("\u3044", "\u3043"); put("\u3046", "\u3045"); put("\u3048", "\u3047"); put("\u304a", "\u3049"); // A
 304                         put("\u3041", "\u3042"); put("\u3043", "\u3044"); put("\u3045", "\u30f4"); put("\u3047", "\u3048"); put("\u3049", "\u304a"); // a
 305                         put("\u304b", "\u304c"); put("\u304d", "\u304e"); put("\u304f", "\u3050"); put("\u3051", "\u3052"); put("\u3053", "\u3054"); // K
 306                         put("\u304c", "\u304b"); put("\u304e", "\u304d"); put("\u3050", "\u304f"); put("\u3052", "\u3051"); put("\u3054", "\u3053"); // k
 307                         put("\u3055", "\u3056"); put("\u3057", "\u3058"); put("\u3059", "\u305a"); put("\u305b", "\u305c"); put("\u305d", "\u305e"); // S
 308                         put("\u3056", "\u3055"); put("\u3058", "\u3057"); put("\u305a", "\u3059"); put("\u305c", "\u305b"); put("\u305e", "\u305d"); // s
 309                         put("\u305f", "\u3060"); put("\u3061", "\u3062"); put("\u3064", "\u3065"); put("\u3066", "\u3067"); put("\u3068", "\u3069"); // T
 310                         put("\u3060", "\u305f"); put("\u3062", "\u3061"); put("\u3065", "\u3063"); put("\u3067", "\u3066"); put("\u3069", "\u3068"); // t
 311                         put("\u3063", "\u3064"); put("\u30f4", "\u3046");
 312                         put("\u306f", "\u3070"); put("\u3072", "\u3073"); put("\u3075", "\u3076"); put("\u3078", "\u3079"); put("\u307b", "\u307c"); // H
 313                         put("\u3070", "\u3071"); put("\u3073", "\u3074"); put("\u3076", "\u3077"); put("\u3079", "\u307a"); put("\u307c", "\u307d"); // h
 314                         put("\u3071", "\u306f"); put("\u3074", "\u3072"); put("\u3077", "\u3075"); put("\u307a", "\u3078"); put("\u307d", "\u307b"); // h.
 315                         put("\u3084", "\u3083"); put("\u3086", "\u3085"); put("\u3088", "\u3087"); // Y
 316                         put("\u3083", "\u3084"); put("\u3085", "\u3086"); put("\u3087", "\u3088"); // y
 317                         put("\u308f", "\u308e");
 318                         put("\u308e", "\u308f");
 319                         put("\u309b", "\u309c");
 320                         put("\u309c", "\u309b");
 321
 322                         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");
 323                         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");
 324                         put("u", "U"); put("v", "V"); put("w", "W"); put("x", "X"); put("y", "Y"); put("z", "Z");
 325                         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");
 326                         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");
 327                         put("U", "u"); put("V", "v"); put("W", "w"); put("X", "x"); put("Y", "y"); put("Z", "z");
 328
 329                         put("1", "\uff11"); put("2", "\uff12"); put("3", "\uff13"); put("4", "\uff14"); put("5", "\uff15");
 330                         put("6", "\uff16"); put("7", "\uff17"); put("8", "\uff18"); put("9", "\uff19"); put("0", "\uff10");
 331                         put("\uff11", "1"); put("\uff12", "2"); put("\uff13", "3"); put("\uff14", "4"); put("\uff15", "5");
 332                         put("\uff16", "6"); put("\uff17", "7"); put("\uff18", "8"); put("\uff19", "9"); put("\uff10", "0");
 333
 334                         put(".", "\uff0e"); put("-", "\u2015"); put("@", "\uff20"); put("_", "\uff3f");
 335                         put("\uff0e", "."); put("\u2015", "-"); put("\uff20", "@"); put("\uff3f", "_");
 336
 337                         put("\uff01", "!"); put("\uff1f", "?");
 338                         put("!", "\uff01"); put("?", "\uff1f");
 339
 340                         put("\u3000", " "); put(" ", "\u3000");
 341
 342                         put("(", "["); put("[", "(");
 343                         put(")", "]"); put("]", ")");
 344                 }};
 345
 346
 347
 348         /** Character table for full-width number */
 349         private static final char[] INSTANT_CHAR_CODE_FULL_NUMBER =
 350                 "\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18\uff19\uff10\uff03\uff0a".toCharArray();
 351
 352         /** Character table for half-width number */
 353         private static final char[] INSTANT_CHAR_CODE_HALF_NUMBER =
 354                 "1234567890#*".toCharArray();
 355
 356         /** The constant for mFixedKeyMode. It means that input mode is not fixed. */
 357         private static final int INVALID_KEYMODE = -1;
 358
 359         /** KeyIndex of "Moji" key on 12 keyboard (depends on the definition of keyboards) */
 360         private static final int KEY_INDEX_CHANGE_MODE_12KEY = 15;
 361
 362         /** KeyIndex of "Moji" key on QWERTY keyboard (depends on the definition of keyboards) */
 363         private static final int KEY_INDEX_CHANGE_MODE_QWERTY = 29;
 364
 365         /** Type of input mode */
 366         private int mInputType = INPUT_TYPE_TOGGLE;
 367
 368         /** Previous input character code */
 369         private int mPrevInputKeyCode = 0;
 370
 371         /** **/
 372         private int mFlickLimitX;
 373         private int mFlickLimitY;
 374
 375         /**
 376          * Character table to input when mInputType becomes INPUT_TYPE_INSTANT.
 377          * (Either INSTANT_CHAR_CODE_FULL_NUMBER or INSTANT_CHAR_CODE_HALF_NUMBER)
 378          */
 379         private char[] mCurrentInstantTable = null;
 380
 381         /** Input mode that is not able to be changed. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */
 382         private int[] mLimitedKeyMode = null;
 383
 384         /** Input mode that is given the first priority. If ENABLE_CHANGE_KEYMODE is set, input mode can change. */
 385         private int mPreferenceKeyMode = INVALID_KEYMODE;
 386
 387         /** The last input type */
 388         private int mLastInputType = 0;
 389
 390         /** Auto caps mode */
 391         private boolean mEnableAutoCaps = true;
 392
 393         /** PopupResId of "Moji" key (this is used for canceling long-press) */
 394         private int mPopupResId = 0;
 395
 396         /** Whether the InputType is null */
 397         private boolean mIsInputTypeNull = false;
 398
 399         /** {@code SharedPreferences} for save the keyboard type */
 400         private SharedPreferences.Editor mPrefEditor = null;
 401
 402         /** "Moji" key (this is used for canceling long-press) */
 403         private Keyboard.Key mChangeModeKey = null;
 404
 405         private boolean mNikoFirst = false;
 406
 407         private Keyboard[][] mNikoKeyboard;
 408         private Keyboard[][] mBellKeyboard;
 409
 410         /** option keyboard type */
 411         private boolean mHookKeyType;
 412         private int     mHookStockKeyType;
 413
 414         /** option bell type **/
 415         private boolean mChangeYLineBellMode;
 416
 417         /** Default constructor */
 418         public DefaultSoftKeyboardJAJP() {
 419                 mCurrentLanguage     = LANG_JA;
 420                 mCurrentKeyboardType = KEYBOARD_12KEY;
 421                 mHookKeyType         = false;
 422                 mHookStockKeyType    = KEYBOARD_12KEY;
 423                 mShiftOn             = KEYBOARD_SHIFT_OFF;
 424                 mCurrentKeyMode      = KEYMODE_JA_FULL_NIKO;
 425                 mCurrentSlide        = NIKO_SLIDE_MODE_TOP;
 426         }
 427
 428         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#createKeyboards */
 429         @Override protected void createKeyboards(NicoWnn parent) {
 430
 431                 /* Keyboard[# of Languages][portrait/landscape][# of keyboard type][shift off/on][max # of key-modes][noinput/input] */
 432                 mKeyboard = new Keyboard[3][2][4][2][9][2];
 433
 434                 SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(parent);
 435                 mChange12keyQwertyMode = pref.getBoolean("change_12key_qwerty", false);
 436                 mChangeYLineBellMode   = pref.getBoolean("change_y_bellmode", false);
 437
 438                 if (mHardKeyboardHidden) {
 439                         /* Create the suitable keyboard object */
 440                         if (mDisplayMode == DefaultSoftKeyboard.PORTRAIT) {
 441                                 //mCurrentKeyboardType = KEYBOARD_12KEY;
 442                                 createKeyboardsPortrait(parent);
 443                                 mFlickLimitX = 24;
 444                                 mFlickLimitY = 24;
 445                         } else {
 446                                 //mCurrentKeyboardType = KEYBOARD_QWERTY;
 447                                 createKeyboardsLandscape(parent);
 448                                 mFlickLimitX = 24;
 449                                 mFlickLimitY = 20;
 450                         }
 451
 452                         if (mCurrentKeyboardType == KEYBOARD_12KEY) {
 453                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE,
 454                                                               NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY));
 455                         } else {
 456                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE,
 457                                                               NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY));
 458                         }
 459                 } else {
 460                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE,
 461                                                       NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY));
 462                 }
 463         }
 464
 465         /**
 466          * Commit the pre-edit string for committing operation that is not explicit
 467          * (ex. when a candidate is selected)
 468          */
 469         private void commitText() {
 470                 if (!mNoInput) {
 471                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.COMMIT_COMPOSING_TEXT));
 472                 }
 473         }
 474
 475         /**
 476          * Change input mode
 477          * <br>
 478          * @param keyMode   The type of input mode
 479          */
 480         public void changeKeyMode(int keyMode) {
 481                 int targetMode = filterKeyMode(keyMode);
 482                 if (targetMode == INVALID_KEYMODE) {
 483                         return;
 484                 }
 485
 486                 commitText();
 487
 488                 if (mCapsLock) {
 489                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY,
 490                                                       new KeyEvent(KeyEvent.ACTION_UP,
 491                                                                    KeyEvent.KEYCODE_SHIFT_LEFT)));
 492                         mCapsLock = false;
 493                 }
 494                 mShiftOn = KEYBOARD_SHIFT_OFF;
 495                 Keyboard kbd = getModeChangeKeyboard(targetMode);
 496                 mCurrentKeyMode = targetMode;
 497                 mPrevInputKeyCode = 0;
 498                 mCurrentSlide = 0;
 499
 500                 int mode = NicoWnnEvent.Mode.DIRECT;
 501
 502                 switch (targetMode) {
 503                 case KEYMODE_JA_FULL_HIRAGANA:
 504                         mInputType = INPUT_TYPE_TOGGLE;
 505                         mode = NicoWnnEvent.Mode.DEFAULT;
 506                         break;
 507
 508                 case KEYMODE_JA_HALF_ALPHABET:
 509                         if (USE_ENGLISH_PREDICT) {
 510                                 mInputType = INPUT_TYPE_TOGGLE;
 511                                 mode = NicoWnnEvent.Mode.NO_LV1_CONV;
 512                         } else {
 513                                 mInputType = INPUT_TYPE_TOGGLE;
 514                                 mode = NicoWnnEvent.Mode.DIRECT;
 515                         }
 516                         break;
 517
 518                 case KEYMODE_JA_FULL_NUMBER:
 519                         mInputType = INPUT_TYPE_INSTANT;
 520                         mode = NicoWnnEvent.Mode.DIRECT;
 521                         mCurrentInstantTable = INSTANT_CHAR_CODE_FULL_NUMBER;
 522                         break;
 523
 524                 case KEYMODE_JA_HALF_NUMBER:
 525                         mInputType = INPUT_TYPE_INSTANT;
 526                         mode = NicoWnnEvent.Mode.DIRECT;
 527                         mCurrentInstantTable = INSTANT_CHAR_CODE_HALF_NUMBER;
 528                         break;
 529
 530                 case KEYMODE_JA_FULL_KATAKANA:
 531                         mInputType = INPUT_TYPE_TOGGLE;
 532                         mode = NicoWnnJAJP.ENGINE_MODE_FULL_KATAKANA;
 533                         break;
 534
 535                 case KEYMODE_JA_FULL_ALPHABET:
 536                         mInputType = INPUT_TYPE_TOGGLE;
 537                         mode = NicoWnnEvent.Mode.DIRECT;
 538                         break;
 539
 540                 case KEYMODE_JA_HALF_KATAKANA:
 541                         mInputType = INPUT_TYPE_TOGGLE;
 542                         mode = NicoWnnJAJP.ENGINE_MODE_HALF_KATAKANA;
 543                         break;
 544
 545                 case KEYMODE_JA_FULL_NIKO:
 546                         mInputType = INPUT_TYPE_TOGGLE;
 547                         mode = NicoWnnEvent.Mode.DEFAULT;
 548                         mNikoFirst = false;
 549                         break;
 550
 551                 default:
 552                         break;
 553                 }
 554
 555                 setStatusIcon();
 556                 changeKeyboard(kbd);
 557                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, mode));
 558
 559                 if (mChange12keyQwertyMode == true) {
 560                         switch (targetMode) {
 561                         case KEYMODE_JA_FULL_ALPHABET:
 562                         case KEYMODE_JA_FULL_NUMBER:
 563                         case KEYMODE_JA_HALF_ALPHABET:
 564                         case KEYMODE_JA_HALF_NUMBER:
 565                                 if (mHookKeyType == false) {
 566                                         mHookStockKeyType = mCurrentKeyboardType;
 567                                         mHookKeyType = true;
 568                                 }
 569                                 changeKeyboardType(KEYBOARD_QWERTY);
 570                                 break;
 571                         default:
 572                                 if (mHookKeyType == true) {
 573                                         mHookKeyType = false;
 574                                         changeKeyboardType(mHookStockKeyType);
 575                                 }
 576                                 break;
 577                         }
 578                 }
 579         }
 580
 581         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#initView */
 582         @Override public View initView(NicoWnn parent, int width, int height) {
 583
 584                 View view = super.initView(parent, width, height);
 585                 SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(parent);
 586                 mChange12keyQwertyMode = pref.getBoolean("change_12key_qwerty", false);
 587                 mChangeYLineBellMode   = pref.getBoolean("change_y_bellmode", false);
 588
 589                 if (mChange12keyQwertyMode == true) {
 590                         switch (mCurrentKeyMode) {
 591                         case KEYMODE_JA_FULL_ALPHABET:
 592                         case KEYMODE_JA_FULL_NUMBER:
 593                         case KEYMODE_JA_HALF_ALPHABET:
 594                         case KEYMODE_JA_HALF_NUMBER:
 595                                 if (mHookKeyType == false) {
 596                                         mHookStockKeyType = mCurrentKeyboardType;
 597                                         mHookKeyType = true;
 598                                 }
 599                                 mCurrentKeyboardType = KEYBOARD_QWERTY;
 600                                 break;
 601                         default:
 602                                 if (mHookKeyType == true) {
 603                                         mHookKeyType = false;
 604                                         mCurrentKeyboardType = mHookStockKeyType;
 605                                 }
 606                                 break;
 607                         }
 608                 }
 609                 else{
 610                         mHookKeyType = false;
 611                         mCurrentKeyboardType = mHookStockKeyType;
 612                 }
 613                 changeKeyboard(mKeyboard[mCurrentLanguage][mDisplayMode][mCurrentKeyboardType][mShiftOn][mCurrentKeyMode][0]);
 614
 615                 return view;
 616         }
 617
 618         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#changeKeyboard */
 619         @Override protected boolean changeKeyboard(Keyboard keyboard) {
 620                 if (keyboard != null) {
 621                         if (mIsInputTypeNull) {
 622                                 mChangeModeKey.popupResId = mPopupResId;
 623                         }
 624
 625                         List<Keyboard.Key> keys = keyboard.getKeys();
 626                         int keyIndex = (KEY_NUMBER_12KEY < keys.size())
 627                                 ? KEY_INDEX_CHANGE_MODE_QWERTY : KEY_INDEX_CHANGE_MODE_12KEY;
 628                         mChangeModeKey = keys.get(keyIndex);
 629
 630                         if (mIsInputTypeNull) {
 631                                 mPopupResId = mChangeModeKey.popupResId;
 632                                 mChangeModeKey.popupResId = 0;
 633                         }
 634                 }
 635                 return super.changeKeyboard(keyboard);
 636         }
 637
 638         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#changeKeyboardType */
 639         @Override public void changeKeyboardType(int type) {
 640                 commitText();
 641                 Keyboard kbd = getTypeChangeKeyboard(type);
 642                 if (kbd != null) {
 643                         mCurrentKeyboardType = type;
 644                         mPrefEditor.putBoolean("opt_enable_qwerty", type == KEYBOARD_QWERTY);
 645                         mPrefEditor.commit();
 646                         changeKeyboard(kbd);
 647                 }
 648                 if (type == KEYBOARD_12KEY) {
 649                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_12KEY));
 650                 } else {
 651                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY));
 652                 }
 653         }
 654         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#setPreferences */
 655         @Override public void setPreferences(SharedPreferences pref, EditorInfo editor) {
 656                 mPrefEditor = pref.edit();
 657                 boolean isQwerty = pref.getBoolean("opt_enable_qwerty", false);
 658                 if (isQwerty && (mCurrentKeyboardType != KEYBOARD_QWERTY)) {
 659                         changeKeyboardType(KEYBOARD_QWERTY);
 660                 }
 661
 662                 super.setPreferences(pref, editor);
 663
 664                 mChange12keyQwertyMode = pref.getBoolean("change_12key_qwerty", false);
 665                 mChangeYLineBellMode   = pref.getBoolean("change_y_bellmode", false);
 666
 667                 int inputType = editor.inputType;
 668                 if (mHardKeyboardHidden) {
 669                         if (inputType == EditorInfo.TYPE_NULL) {
 670                                 if (!mIsInputTypeNull) {
 671                                         mIsInputTypeNull = true;
 672                                         mPopupResId = mChangeModeKey.popupResId;
 673                                         mChangeModeKey.popupResId = 0;
 674                                 }
 675                                 return;
 676                         }
 677
 678                         if (mIsInputTypeNull) {
 679                                 mIsInputTypeNull = false;
 680                                 mChangeModeKey.popupResId = mPopupResId;
 681                         }
 682                 }
 683
 684                 mEnableAutoCaps = pref.getBoolean("auto_caps", true);
 685                 mLimitedKeyMode = null;
 686                 mPreferenceKeyMode = INVALID_KEYMODE;
 687                 mNoInput = true;
 688                 mDisableKeyInput = false;
 689                 mCapsLock = false;
 690
 691                 switch (inputType & EditorInfo.TYPE_MASK_CLASS) {
 692
 693                 case EditorInfo.TYPE_CLASS_NUMBER:
 694                 case EditorInfo.TYPE_CLASS_DATETIME:
 695                         mPreferenceKeyMode = KEYMODE_JA_HALF_NUMBER;
 696                         break;
 697
 698                 case EditorInfo.TYPE_CLASS_PHONE:
 699                         if (mHardKeyboardHidden) {
 700                             //mLimitedKeyMode = new int[] {KEYMODE_JA_FULL_NIKO};
 701                             mPreferenceKeyMode = KEYMODE_JA_FULL_NIKO;
 702                         } else {
 703                             //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET};
 704                             mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET;
 705                         }
 706                         break;
 707
 708                 case EditorInfo.TYPE_CLASS_TEXT:
 709                         switch (inputType & EditorInfo.TYPE_MASK_VARIATION) {
 710
 711                         case EditorInfo.TYPE_TEXT_VARIATION_PASSWORD:
 712                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER};
 713                                 break;
 714
 715                         case EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS:
 716                                 //mLimitedKeyMode = new int[] {KEYMODE_JA_HALF_ALPHABET, KEYMODE_JA_HALF_NUMBER};
 717                                 break;
 718                         case EditorInfo.TYPE_TEXT_VARIATION_URI:
 719                                 //mPreferenceKeyMode = KEYMODE_JA_HALF_ALPHABET;
 720                                 mPreferenceKeyMode = KEYMODE_JA_FULL_NIKO;
 721                                 break;
 722
 723                         default:
 724                                 break;
 725                         }
 726                         break;
 727
 728                 default:
 729                         break;
 730                 }
 731
 732                 if (inputType != mLastInputType) {
 733                         setDefaultKeyboard();
 734                         mLastInputType = inputType;
 735                 }
 736
 737                 setStatusIcon();
 738                 setShiftByEditorInfo();
 739         }
 740
 741         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#onUpdateState */
 742         @Override public void onUpdateState(NicoWnn parent) {
 743                 super.onUpdateState(parent);
 744                 if (!mCapsLock) {
 745                         setShiftByEditorInfo();
 746                         if (true == mNoInput && true == mNikoFirst) {
 747                                 resetNikoKeyboard();
 748                         }
 749                 }
 750         }
 751         /**
 752          * Change the keyboard to default
 753          */
 754         public void setDefaultKeyboard() {
 755                 Locale locale = Locale.getDefault();
 756                 int keymode = KEYMODE_JA_FULL_NIKO;
 757
 758
 759                 if (mPreferenceKeyMode != INVALID_KEYMODE) {
 760                         keymode = mPreferenceKeyMode;
 761                 } else if (mLimitedKeyMode != null) {
 762                         keymode = mLimitedKeyMode[0];
 763                 } else {
 764                         if (!locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) {
 765                                 keymode = KEYMODE_JA_HALF_ALPHABET;
 766                         }
 767                 }
 768
 769                 changeKeyMode(keymode);
 770         }
 771
 772
 773         /**
 774          * Change to the next input mode
 775          */
 776         public void nextKeyMode() {
 777                 /* Search the current mode in the toggle table */
 778                 boolean found = false;
 779                 int index;
 780                 for (index = 0; index < JP_MODE_CYCLE_TABLE.length; index++) {
 781                         if (JP_MODE_CYCLE_TABLE[index] == mCurrentKeyMode) {
 782                                 found = true;
 783                                 break;
 784                         }
 785                 }
 786
 787                 if (!found) {
 788                         /* If the current mode not exists, set the default mode */
 789                         setDefaultKeyboard();
 790                 } else {
 791                         /* If the current mode exists, set the next input mode */
 792                         int size = JP_MODE_CYCLE_TABLE.length;
 793                         int keyMode = INVALID_KEYMODE;
 794                         for (int i = 0; i < size; i++) {
 795                                 index = (++index) % size;
 796
 797                                 keyMode = filterKeyMode(JP_MODE_CYCLE_TABLE[index]);
 798                                 if (keyMode != INVALID_KEYMODE) {
 799                                         break;
 800                                 }
 801                         }
 802
 803                         if (keyMode != INVALID_KEYMODE) {
 804                                 changeKeyMode(keyMode);
 805                         }
 806                 }
 807         }
 808
 809         /**
 810          * Create the keyboard for portrait mode
 811          * <br>
 812          * @param parent  The context
 813          */
 814         private void createKeyboardsPortrait(NicoWnn parent) {
 815                 Keyboard[][] keyList;
 816                 /* qwerty shift_off (portrait) */
 817                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF];
 818                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp);
 819                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet);
 820                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols);
 821                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana);
 822                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet);
 823                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols);
 824                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana);
 825                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);
 826                 keyList[KEYMODE_JA_FULL_NIKO][0]     = keyList[KEYMODE_JA_FULL_HIRAGANA][0];
 827
 828                 /* qwerty shift_on (portrait) */
 829                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON];
 830                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift);
 831                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift);
 832                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift);
 833                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana_shift);
 834                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift);
 835                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift);
 836                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana_shift);
 837                 keyList[KEYMODE_JA_HALF_PHONE][0]    = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0];
 838                 keyList[KEYMODE_JA_FULL_NIKO][0]     = keyList[KEYMODE_JA_FULL_HIRAGANA][0];
 839
 840                 /* 12-keys shift_off (portrait) */
 841                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 842                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp);
 843                 keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input);
 844                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana);
 845                 keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana_input);
 846                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana);
 847                 keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana_input);
 848                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone);
 849
 850                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet);
 851                 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input);
 852                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_num);
 853                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet);
 854                 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input);
 855                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_half_num);
 856
 857                 /* 12-keys shift_on (portrait) */
 858                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 859                 keyList[KEYMODE_JA_FULL_HIRAGANA] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA];
 860                 keyList[KEYMODE_JA_FULL_KATAKANA] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA];
 861                 keyList[KEYMODE_JA_HALF_KATAKANA] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA];
 862                 keyList[KEYMODE_JA_HALF_PHONE]    = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE];
 863
 864                 keyList[KEYMODE_JA_FULL_ALPHABET] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET];
 865                 keyList[KEYMODE_JA_FULL_NUMBER]   = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER];
 866                 keyList[KEYMODE_JA_HALF_ALPHABET] = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];;
 867                 keyList[KEYMODE_JA_HALF_NUMBER]   = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER];
 868
 869                 // nikotouch slide
 870                 mNikoKeyboard = new Keyboard[11][2];
 871                 mNikoKeyboard[NIKO_SLIDE_MODE_TOP][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_niko_top);
 872                 mNikoKeyboard[NIKO_SLIDE_MODE_A][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_a);
 873                 mNikoKeyboard[NIKO_SLIDE_MODE_K][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_k);
 874                 mNikoKeyboard[NIKO_SLIDE_MODE_S][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_s);
 875                 mNikoKeyboard[NIKO_SLIDE_MODE_T][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_t);
 876                 mNikoKeyboard[NIKO_SLIDE_MODE_N][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_n);
 877                 mNikoKeyboard[NIKO_SLIDE_MODE_H][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_h);
 878                 mNikoKeyboard[NIKO_SLIDE_MODE_M][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_m);
 879                 mNikoKeyboard[NIKO_SLIDE_MODE_Y][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_y);
 880                 mNikoKeyboard[NIKO_SLIDE_MODE_R][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_r);
 881                 mNikoKeyboard[NIKO_SLIDE_MODE_W][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_w);
 882
 883                 mNikoKeyboard[NIKO_SLIDE_MODE_TOP][1]   = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_top);
 884                 mNikoKeyboard[NIKO_SLIDE_MODE_A][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_a);
 885                 mNikoKeyboard[NIKO_SLIDE_MODE_K][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_k);
 886                 mNikoKeyboard[NIKO_SLIDE_MODE_S][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_s);
 887                 mNikoKeyboard[NIKO_SLIDE_MODE_T][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_t);
 888                 mNikoKeyboard[NIKO_SLIDE_MODE_N][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_n);
 889                 mNikoKeyboard[NIKO_SLIDE_MODE_H][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_h);
 890                 mNikoKeyboard[NIKO_SLIDE_MODE_M][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_m);
 891                 mNikoKeyboard[NIKO_SLIDE_MODE_Y][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_y);
 892                 mNikoKeyboard[NIKO_SLIDE_MODE_R][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_r);
 893                 mNikoKeyboard[NIKO_SLIDE_MODE_W][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_w);
 894
 895                 // belltouch slide
 896                 mBellKeyboard = new Keyboard[11][2];
 897                 mBellKeyboard[NIKO_SLIDE_MODE_TOP][0]   = mNikoKeyboard[NIKO_SLIDE_MODE_TOP][0];
 898                 mBellKeyboard[NIKO_SLIDE_MODE_A][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_A][0];
 899                 mBellKeyboard[NIKO_SLIDE_MODE_K][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_K][0];
 900                 mBellKeyboard[NIKO_SLIDE_MODE_S][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_S][0];
 901                 mBellKeyboard[NIKO_SLIDE_MODE_T][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_T][0];
 902                 mBellKeyboard[NIKO_SLIDE_MODE_N][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_N][0];
 903                 mBellKeyboard[NIKO_SLIDE_MODE_H][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_H][0];
 904                 mBellKeyboard[NIKO_SLIDE_MODE_M][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_M][0];
 905                 mBellKeyboard[NIKO_SLIDE_MODE_Y][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_bell_y);
 906                 mBellKeyboard[NIKO_SLIDE_MODE_R][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_R][0];
 907                 mBellKeyboard[NIKO_SLIDE_MODE_W][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_W][0];
 908
 909                 mBellKeyboard[NIKO_SLIDE_MODE_TOP][1]   = mNikoKeyboard[NIKO_SLIDE_MODE_TOP][1];
 910                 mBellKeyboard[NIKO_SLIDE_MODE_A][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_A][1];
 911                 mBellKeyboard[NIKO_SLIDE_MODE_K][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_K][1];
 912                 mBellKeyboard[NIKO_SLIDE_MODE_S][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_S][1];
 913                 mBellKeyboard[NIKO_SLIDE_MODE_T][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_T][1];
 914                 mBellKeyboard[NIKO_SLIDE_MODE_N][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_N][1];
 915                 mBellKeyboard[NIKO_SLIDE_MODE_H][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_H][1];
 916                 mBellKeyboard[NIKO_SLIDE_MODE_M][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_M][1];
 917                 mBellKeyboard[NIKO_SLIDE_MODE_Y][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_bell_input_y);
 918                 mBellKeyboard[NIKO_SLIDE_MODE_R][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_R][1];
 919                 mBellKeyboard[NIKO_SLIDE_MODE_W][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_W][1];
 920
 921                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 922                 keyList[KEYMODE_JA_FULL_NIKO]     = mNikoKeyboard[NIKO_SLIDE_MODE_TOP];
 923                 keyList = mKeyboard[LANG_JA][PORTRAIT][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 924                 if (false == mChangeYLineBellMode) {
 925                         keyList[KEYMODE_JA_FULL_NIKO]     = mNikoKeyboard[NIKO_SLIDE_MODE_A];
 926                 }
 927                 else{
 928                         keyList[KEYMODE_JA_FULL_NIKO]     = mBellKeyboard[NIKO_SLIDE_MODE_A];
 929                 }
 930         }
 931
 932         /**
 933          * Create the keyboard for landscape mode
 934          * <br>
 935          * @param parent  The context
 936          */
 937         private void createKeyboardsLandscape(NicoWnn parent) {
 938                 Keyboard[][] keyList;
 939                 /* qwerty shift_off (landscape) */
 940                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF];
 941                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_land);
 942                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_land);
 943                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_land);
 944                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana_land);
 945                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_land);
 946                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_land);
 947                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana_land);
 948                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone_land);
 949                 keyList[KEYMODE_JA_FULL_NIKO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp_niko_land);
 950                 /* qwerty shift_on (landscape) */
 951                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_ON];
 952                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_shift_land);
 953                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_alphabet_shift_land);
 954                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_symbols_shift_land);
 955                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_full_katakana_shift_land);
 956                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_alphabet_shift_land);
 957                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_symbols_shift_land);
 958                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_qwerty_jp_half_katakana_shift_land);
 959                 keyList[KEYMODE_JA_HALF_PHONE][0]    = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_QWERTY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE][0];
 960                 keyList[KEYMODE_JA_FULL_NIKO][0]     = new Keyboard(parent, R.xml.keyboard_qwerty_jp_niko_shift_land);
 961
 962                 /* 12-keys shift_off (landscape) */
 963                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
 964                 keyList[KEYMODE_JA_FULL_HIRAGANA][0] = new Keyboard(parent, R.xml.keyboard_12keyjp_land);
 965                 keyList[KEYMODE_JA_FULL_HIRAGANA][1] = new Keyboard(parent, R.xml.keyboard_12keyjp_input_land);
 966                 keyList[KEYMODE_JA_FULL_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_land);
 967                 keyList[KEYMODE_JA_FULL_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_full_alphabet_input_land);
 968                 keyList[KEYMODE_JA_FULL_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_num_land);
 969                 keyList[KEYMODE_JA_FULL_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana_land);
 970                 keyList[KEYMODE_JA_FULL_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_full_katakana_input_land);
 971                 keyList[KEYMODE_JA_HALF_ALPHABET][0] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_land);
 972                 keyList[KEYMODE_JA_HALF_ALPHABET][1] = new Keyboard(parent, R.xml.keyboard_12key_half_alphabet_input_land);
 973                 keyList[KEYMODE_JA_HALF_NUMBER][0]   = new Keyboard(parent, R.xml.keyboard_12key_half_num_land);
 974                 keyList[KEYMODE_JA_HALF_KATAKANA][0] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana_land);
 975                 keyList[KEYMODE_JA_HALF_KATAKANA][1] = new Keyboard(parent, R.xml.keyboard_12key_half_katakana_input_land);
 976                 keyList[KEYMODE_JA_HALF_PHONE][0]    = new Keyboard(parent, R.xml.keyboard_12key_phone_land);
 977
 978                 /* 12-keys shift_on (landscape) */
 979                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
 980                 keyList[KEYMODE_JA_FULL_HIRAGANA] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_HIRAGANA];
 981                 keyList[KEYMODE_JA_FULL_ALPHABET] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_ALPHABET];
 982                 keyList[KEYMODE_JA_FULL_NUMBER]   = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_NUMBER];
 983                 keyList[KEYMODE_JA_FULL_KATAKANA] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_FULL_KATAKANA];
 984                 keyList[KEYMODE_JA_HALF_ALPHABET] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_ALPHABET];;
 985                 keyList[KEYMODE_JA_HALF_NUMBER]   = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_NUMBER];
 986                 keyList[KEYMODE_JA_HALF_KATAKANA] = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_KATAKANA];
 987                 keyList[KEYMODE_JA_HALF_PHONE]    = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF][KEYMODE_JA_HALF_PHONE];
 988
 989                 // nikotouch slide
 990                 mNikoKeyboard = new Keyboard[11][2];
 991                 mNikoKeyboard[NIKO_SLIDE_MODE_TOP][0]   = new Keyboard(parent, R.xml.keyboard_12key_full_niko_top_land);
 992                 mNikoKeyboard[NIKO_SLIDE_MODE_A][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_a_land);
 993                 mNikoKeyboard[NIKO_SLIDE_MODE_K][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_k_land);
 994                 mNikoKeyboard[NIKO_SLIDE_MODE_S][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_s_land);
 995                 mNikoKeyboard[NIKO_SLIDE_MODE_T][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_t_land);
 996                 mNikoKeyboard[NIKO_SLIDE_MODE_N][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_n_land);
 997                 mNikoKeyboard[NIKO_SLIDE_MODE_H][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_h_land);
 998                 mNikoKeyboard[NIKO_SLIDE_MODE_M][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_m_land);
 999                 mNikoKeyboard[NIKO_SLIDE_MODE_Y][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_y_land);
1000                 mNikoKeyboard[NIKO_SLIDE_MODE_R][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_r_land);
1001                 mNikoKeyboard[NIKO_SLIDE_MODE_W][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_w_land);
1002
1003                 mNikoKeyboard[NIKO_SLIDE_MODE_TOP][1]   = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_top_land);
1004                 mNikoKeyboard[NIKO_SLIDE_MODE_A][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_a_land);
1005                 mNikoKeyboard[NIKO_SLIDE_MODE_K][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_k_land);
1006                 mNikoKeyboard[NIKO_SLIDE_MODE_S][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_s_land);
1007                 mNikoKeyboard[NIKO_SLIDE_MODE_T][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_t_land);
1008                 mNikoKeyboard[NIKO_SLIDE_MODE_N][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_n_land);
1009                 mNikoKeyboard[NIKO_SLIDE_MODE_H][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_h_land);
1010                 mNikoKeyboard[NIKO_SLIDE_MODE_M][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_m_land);
1011                 mNikoKeyboard[NIKO_SLIDE_MODE_Y][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_y_land);
1012                 mNikoKeyboard[NIKO_SLIDE_MODE_R][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_r_land);
1013                 mNikoKeyboard[NIKO_SLIDE_MODE_W][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_niko_input_w_land);
1014
1015                 // belltouch slide
1016                 mBellKeyboard = new Keyboard[11][2];
1017                 mBellKeyboard[NIKO_SLIDE_MODE_TOP][0]   = mNikoKeyboard[NIKO_SLIDE_MODE_TOP][0];
1018                 mBellKeyboard[NIKO_SLIDE_MODE_A][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_A][0];
1019                 mBellKeyboard[NIKO_SLIDE_MODE_K][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_K][0];
1020                 mBellKeyboard[NIKO_SLIDE_MODE_S][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_S][0];
1021                 mBellKeyboard[NIKO_SLIDE_MODE_T][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_T][0];
1022                 mBellKeyboard[NIKO_SLIDE_MODE_N][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_N][0];
1023                 mBellKeyboard[NIKO_SLIDE_MODE_H][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_H][0];
1024                 mBellKeyboard[NIKO_SLIDE_MODE_M][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_M][0];
1025                 mBellKeyboard[NIKO_SLIDE_MODE_Y][0]     = new Keyboard(parent, R.xml.keyboard_12key_full_bell_y_land);
1026                 mBellKeyboard[NIKO_SLIDE_MODE_R][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_R][0];
1027                 mBellKeyboard[NIKO_SLIDE_MODE_W][0]     = mNikoKeyboard[NIKO_SLIDE_MODE_W][0];
1028
1029                 mBellKeyboard[NIKO_SLIDE_MODE_TOP][1]   = mNikoKeyboard[NIKO_SLIDE_MODE_TOP][1];
1030                 mBellKeyboard[NIKO_SLIDE_MODE_A][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_A][1];
1031                 mBellKeyboard[NIKO_SLIDE_MODE_K][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_K][1];
1032                 mBellKeyboard[NIKO_SLIDE_MODE_S][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_S][1];
1033                 mBellKeyboard[NIKO_SLIDE_MODE_T][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_T][1];
1034                 mBellKeyboard[NIKO_SLIDE_MODE_N][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_N][1];
1035                 mBellKeyboard[NIKO_SLIDE_MODE_H][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_H][1];
1036                 mBellKeyboard[NIKO_SLIDE_MODE_M][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_M][1];
1037                 mBellKeyboard[NIKO_SLIDE_MODE_Y][1]     = new Keyboard(parent, R.xml.keyboard_12key_full_bell_input_y_land);
1038                 mBellKeyboard[NIKO_SLIDE_MODE_R][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_R][1];
1039                 mBellKeyboard[NIKO_SLIDE_MODE_W][1]     = mNikoKeyboard[NIKO_SLIDE_MODE_W][1];
1040
1041                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_OFF];
1042                 keyList[KEYMODE_JA_FULL_NIKO]     = mNikoKeyboard[NIKO_SLIDE_MODE_TOP];
1043                 keyList = mKeyboard[LANG_JA][LANDSCAPE][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
1044                 if (false == mChangeYLineBellMode) {
1045                         keyList[KEYMODE_JA_FULL_NIKO]     = mNikoKeyboard[NIKO_SLIDE_MODE_A];
1046                 }
1047                 else{
1048                         keyList[KEYMODE_JA_FULL_NIKO]     = mBellKeyboard[NIKO_SLIDE_MODE_A];
1049                 }
1050         }
1051
1052         /**
1053          * Convert the key code to the index of table
1054          * <br>
1055          * @param index     The key code
1056          * @return          The index of the toggle table for input
1057          */
1058         private int getTableIndex(int keyCode) {
1059                 int index =
1060                         (keyCode == KEYCODE_JP12_1)     ?  0 :
1061                         (keyCode == KEYCODE_JP12_2)     ?  1 :
1062                         (keyCode == KEYCODE_JP12_3)     ?  2 :
1063                         (keyCode == KEYCODE_JP12_4)     ?  3 :
1064                         (keyCode == KEYCODE_JP12_5)     ?  4 :
1065                         (keyCode == KEYCODE_JP12_6)     ?  5 :
1066                         (keyCode == KEYCODE_JP12_7)     ?  6 :
1067                         (keyCode == KEYCODE_JP12_8)     ?  7 :
1068                         (keyCode == KEYCODE_JP12_9)     ?  8 :
1069                         (keyCode == KEYCODE_JP12_0)     ?  9 :
1070                         (keyCode == KEYCODE_JP12_SHARP) ? 10 :
1071                         (keyCode == KEYCODE_JP12_ASTER) ? 11 :
1072                         0;
1073
1074                 return index;
1075         }
1076
1077         /**
1078          * Get the toggle table for input that is appropriate in current mode.
1079          *
1080          * @return      The toggle table for input
1081          */
1082         private String[][] getCycleTable() {
1083                 String[][] cycleTable = null;
1084                 switch (mCurrentKeyMode) {
1085                 case KEYMODE_JA_FULL_HIRAGANA:
1086                         cycleTable = JP_FULL_HIRAGANA_CYCLE_TABLE;
1087                         break;
1088
1089                 case KEYMODE_JA_FULL_KATAKANA:
1090                         cycleTable = JP_FULL_KATAKANA_CYCLE_TABLE;
1091                         break;
1092
1093                 case KEYMODE_JA_FULL_ALPHABET:
1094                         cycleTable = JP_FULL_ALPHABET_CYCLE_TABLE;
1095                         break;
1096
1097                 case KEYMODE_JA_FULL_NUMBER:
1098                 case KEYMODE_JA_HALF_NUMBER:
1099                         /* Because these modes belong to direct input group, No toggle table exists */
1100                         break;
1101
1102                 case KEYMODE_JA_HALF_ALPHABET:
1103                         cycleTable = JP_HALF_ALPHABET_CYCLE_TABLE;
1104                         break;
1105
1106                 case KEYMODE_JA_HALF_KATAKANA:
1107                         cycleTable = JP_HALF_KATAKANA_CYCLE_TABLE;
1108                         break;
1109
1110                 case KEYMODE_JA_FULL_NIKO:
1111                         cycleTable = JP_FULL_NIKO_CYCLE_TABLE;
1112                         break;
1113
1114                 default:
1115                         break;
1116                 }
1117                 return cycleTable;
1118         }
1119
1120         /**
1121          * Get the replace table that is appropriate in current mode.
1122          *
1123          * @return      The replace table
1124          */
1125         private HashMap getReplaceTable() {
1126                 HashMap hashTable = null;
1127                 switch (mCurrentKeyMode) {
1128                 case KEYMODE_JA_FULL_HIRAGANA:
1129                         hashTable = JP_FULL_HIRAGANA_REPLACE_TABLE;
1130                         break;
1131                 case KEYMODE_JA_FULL_KATAKANA:
1132                         hashTable = JP_FULL_KATAKANA_REPLACE_TABLE;
1133                         break;
1134
1135                 case KEYMODE_JA_FULL_ALPHABET:
1136                         hashTable = JP_FULL_ALPHABET_REPLACE_TABLE;
1137                         break;
1138
1139                 case KEYMODE_JA_FULL_NUMBER:
1140                 case KEYMODE_JA_HALF_NUMBER:
1141                         /* Because these modes belong to direct input group, No replacing table exists */
1142                         break;
1143
1144                 case KEYMODE_JA_HALF_ALPHABET:
1145                         hashTable = JP_HALF_ALPHABET_REPLACE_TABLE;
1146                         break;
1147
1148                 case KEYMODE_JA_HALF_KATAKANA:
1149                         hashTable = JP_HALF_KATAKANA_REPLACE_TABLE;
1150                         break;
1151
1152                 case KEYMODE_JA_FULL_NIKO:
1153                         hashTable = JP_FULL_NIKO_REPLACE_TABLE;
1154                         break;
1155
1156                 default:
1157                         break;
1158                 }
1159                 return hashTable;
1160         }
1161
1162         /**
1163          * Set the status icon that is appropriate in current mode
1164          */
1165         private void setStatusIcon() {
1166                 int icon = 0;
1167
1168                 switch (mCurrentKeyMode) {
1169                 case KEYMODE_JA_FULL_HIRAGANA:
1170                         icon = R.drawable.immodeic_hiragana;
1171                         break;
1172                 case KEYMODE_JA_FULL_KATAKANA:
1173                         icon = R.drawable.immodeic_full_kana;
1174                         break;
1175                 case KEYMODE_JA_FULL_ALPHABET:
1176                         icon = R.drawable.immodeic_full_alphabet;
1177                         break;
1178                 case KEYMODE_JA_FULL_NUMBER:
1179                         icon = R.drawable.immodeic_full_number;
1180                         break;
1181                 case KEYMODE_JA_HALF_KATAKANA:
1182                         icon = R.drawable.immodeic_half_kana;
1183                         break;
1184                 case KEYMODE_JA_HALF_ALPHABET:
1185                         icon = R.drawable.immodeic_half_alphabet;
1186                         break;
1187                 case KEYMODE_JA_HALF_NUMBER:
1188                 case KEYMODE_JA_HALF_PHONE:
1189                         icon = R.drawable.immodeic_half_number;
1190                         break;
1191                 case KEYMODE_JA_FULL_NIKO:
1192                         icon = R.drawable.immodeic_niko;
1193                         break;
1194
1195                 default:
1196                         break;
1197                 }
1198
1199                 mWnn.showStatusIcon(icon);
1200         }
1201
1202         /**
1203          * Get the shift key state from the editor.
1204          * <br>
1205          * @param editor    The editor information
1206          * @return          The state id of the shift key (0:off, 1:on)
1207          */
1208         protected int getShiftKeyState(EditorInfo editor) {
1209                 InputConnection connection = mWnn.getCurrentInputConnection();
1210                 if (connection != null) {
1211                         int caps = connection.getCursorCapsMode(editor.inputType);
1212                         return (caps == 0) ? 0 : 1;
1213                 } else {
1214                         return 0;
1215                 }
1216         }
1217
1218         /**
1219          * Set the shift key state from {@link EditorInfo}.
1220          */
1221         private void setShiftByEditorInfo() {
1222                 if (mEnableAutoCaps && (mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)) {
1223                         int shift = getShiftKeyState(mWnn.getCurrentInputEditorInfo());
1224
1225                         mShiftOn = shift;
1226                         changeKeyboard(getShiftChangeKeyboard(shift));
1227                 }
1228         }
1229
1230         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#setHardKeyboardHidden */
1231         @Override public void setHardKeyboardHidden(boolean hidden) {
1232                 if (mWnn != null) {
1233                         if (!hidden) {
1234                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE,
1235                                                               NicoWnnJAJP.ENGINE_MODE_OPT_TYPE_QWERTY));
1236                         }
1237
1238                         if (mHardKeyboardHidden != hidden) {
1239                                 if ((mLimitedKeyMode != null)
1240                                     || ((mCurrentKeyMode != KEYMODE_JA_FULL_HIRAGANA)
1241                                         && (mCurrentKeyMode != KEYMODE_JA_HALF_ALPHABET))) {
1242
1243                                         mLastInputType = EditorInfo.TYPE_NULL;
1244                                         if (mWnn.isInputViewShown()) {
1245                                                 setDefaultKeyboard();
1246                                         }
1247                                 }
1248                         }
1249                 }
1250                 super.setHardKeyboardHidden(hidden);
1251         }
1252
1253         /**
1254          * Change the key-mode to the allowed one which is restricted
1255          *  by the text input field or the type of the keyboard.
1256          * @param keyMode The key-mode
1257          * @return the key-mode allowed
1258          */
1259         private int filterKeyMode(int keyMode) {
1260                 int targetMode = keyMode;
1261                 int[] limits = mLimitedKeyMode;
1262
1263                 if (!mHardKeyboardHidden) { /* for hardware keyboard */
1264                         if ((targetMode != KEYMODE_JA_FULL_HIRAGANA)
1265                             && (targetMode != KEYMODE_JA_HALF_ALPHABET)) {
1266
1267                                 Locale locale = Locale.getDefault();
1268                                 int keymode = KEYMODE_JA_HALF_ALPHABET;
1269                                 if (locale.getLanguage().equals(Locale.JAPANESE.getLanguage())) {
1270                                         switch (targetMode) {
1271                                         case KEYMODE_JA_FULL_HIRAGANA:
1272                                         case KEYMODE_JA_FULL_KATAKANA:
1273                                         case KEYMODE_JA_HALF_KATAKANA:
1274                                                 keymode = KEYMODE_JA_FULL_HIRAGANA;
1275                                                 break;
1276                                         default:
1277                                                 /* half-alphabet */
1278                                                 break;
1279                                         }
1280                                 }
1281                                 targetMode = keymode;
1282                         }
1283                 }
1284
1285                 /* restrict by the type of the text field */
1286                 if (limits != null) {
1287                         boolean hasAccepted = false;
1288                         boolean hasRequiredChange = true;
1289                         int size = limits.length;
1290                         int nowMode = mCurrentKeyMode;
1291
1292                         for (int i = 0; i < size; i++) {
1293                                 if (targetMode == limits[i]) {
1294                                         hasAccepted = true;
1295                                         break;
1296                                 }
1297                                 if (nowMode == limits[i]) {
1298                                         hasRequiredChange = false;
1299                                 }
1300                         }
1301
1302                         if (!hasAccepted) {
1303                                 if (hasRequiredChange) {
1304                                         targetMode = mLimitedKeyMode[0];
1305                                 } else {
1306                                         targetMode = INVALID_KEYMODE;
1307                                 }
1308                         }
1309                 }
1310
1311                 return targetMode;
1312         }
1313
1314
1315
1316         /*****************************************
1317          * onkey (normal)
1318          */
1319         /** @see com.hiroshica.android.input.nicownn2.DefaultSoftKeyboard#onKey */
1320         @Override public void onKey(int primaryCode, int[] keyCodes) {
1321
1322                 if (mDisableKeyInput) {
1323                         return;
1324                 }
1325
1326                 if (mCurrentKeyMode == KEYMODE_JA_FULL_NIKO) {
1327                         if (true == onKeyNiko(primaryCode, keyCodes)) {
1328                                 /* update shift key's state */
1329                                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
1330                                         setShiftByEditorInfo();
1331                                 }
1332                                 return;
1333                         }
1334                 }
1335                 if (true == mIsEnableFlick) {
1336                         onkeyFlick(primaryCode, keyCodes);
1337                         return;
1338                 }
1339
1340                 switch (primaryCode) {
1341                 case KEYCODE_JP12_TOGGLE_MODE:
1342                 case KEYCODE_QWERTY_TOGGLE_MODE:
1343                         if (!mIsInputTypeNull) {
1344                                 nextKeyMode();
1345                         }
1346                         break;
1347
1348                 case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE:
1349                 case KEYCODE_JP12_BACKSPACE:
1350                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY,
1351                                                       new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL)));
1352                         break;
1353
1354                 case DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT:
1355                         toggleShiftLock();
1356                         break;
1357
1358                 case DefaultSoftKeyboard.KEYCODE_QWERTY_ALT:
1359                         processAltKey();
1360                         break;
1361
1362                 case KEYCODE_QWERTY_ENTER:
1363                 case KEYCODE_JP12_ENTER:
1364                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY,
1365                                                       new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER)));
1366                         break;
1367
1368                 case KEYCODE_JP12_REVERSE:
1369                         if (!mNoInput) {
1370                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_REVERSE_CHAR, mCurrentCycleTable));
1371                         }
1372                         break;
1373
1374                 case KEYCODE_QWERTY_KBD:
1375                         changeKeyboardType(KEYBOARD_12KEY);
1376                         mHookKeyType = false;
1377                         mHookStockKeyType = KEYBOARD_12KEY;
1378                         break;
1379
1380                 case KEYCODE_JP12_KBD:
1381                         changeKeyboardType(KEYBOARD_QWERTY);
1382                         mHookKeyType = false;
1383                         mHookStockKeyType = KEYBOARD_QWERTY;
1384                         break;
1385
1386                 case KEYCODE_JP12_EMOJI:
1387                 case KEYCODE_QWERTY_EMOJI:
1388                         commitText();
1389                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_SYMBOL));
1390                         break;
1391
1392                 case KEYCODE_JP12_1:
1393                 case KEYCODE_JP12_2:
1394                 case KEYCODE_JP12_3:
1395                 case KEYCODE_JP12_4:
1396                 case KEYCODE_JP12_5:
1397                 case KEYCODE_JP12_6:
1398                 case KEYCODE_JP12_7:
1399                 case KEYCODE_JP12_8:
1400                 case KEYCODE_JP12_9:
1401                 case KEYCODE_JP12_0:
1402                 case KEYCODE_JP12_SHARP:
1403                         /* Processing to input by ten key */
1404                         if (mInputType == INPUT_TYPE_INSTANT) {
1405                                 /* Send a input character directly if instant input type is selected */
1406                                 commitText();
1407                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR,
1408                                                               mCurrentInstantTable[getTableIndex(primaryCode)]));
1409                         } else {
1410                                 if ((mPrevInputKeyCode != primaryCode)) {
1411                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOUCH_OTHER_KEY));
1412                                         if ((mCurrentKeyMode == KEYMODE_JA_HALF_ALPHABET)
1413                                             && (primaryCode == KEYCODE_JP12_SHARP)) {
1414                                                 /* Commit text by symbol character (',' '.') when alphabet input mode is selected */
1415                                                 commitText();
1416                                         }
1417                                 }
1418
1419                                 /* Convert the key code to the table index and send the toggle event with the table index */
1420                                 String[][] cycleTable = getCycleTable();
1421                                 if (cycleTable == null) {
1422                                         Log.e("NicoWnn", "not founds cycle table");
1423                                 } else {
1424                                         int index = getTableIndex(primaryCode);
1425                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[index]));
1426                                         mCurrentCycleTable = cycleTable[index];
1427                                 }
1428                                 mPrevInputKeyCode = primaryCode;
1429                         }
1430                         break;
1431
1432                 case KEYCODE_JP12_ASTER:
1433                         if (mInputType == INPUT_TYPE_INSTANT) {
1434                                 commitText();
1435                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR,
1436                                                               mCurrentInstantTable[getTableIndex(primaryCode)]));
1437                         } else {
1438                                 if (!mNoInput) {
1439                                         /* Processing to toggle Dakuten, Handakuten, and capital */
1440                                         HashMap replaceTable = getReplaceTable();
1441                                         if (replaceTable == null) {
1442                                                 Log.e("NicoWnn", "not founds replace table");
1443                                         } else {
1444                                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.REPLACE_CHAR, replaceTable));
1445                                                 mPrevInputKeyCode = primaryCode;
1446                                         }
1447                                 }
1448                         }
1449                         break;
1450
1451                 case KEYCODE_SWITCH_FULL_HIRAGANA:
1452                         /* Change mode to Full width hiragana */
1453                         changeKeyMode(KEYMODE_JA_FULL_HIRAGANA);
1454                         break;
1455
1456                 case KEYCODE_SWITCH_FULL_KATAKANA:
1457                         /* Change mode to Full width katakana */
1458                         changeKeyMode(KEYMODE_JA_FULL_KATAKANA);
1459                         break;
1460
1461                 case KEYCODE_SWITCH_FULL_ALPHABET:
1462                         /* Change mode to Full width alphabet */
1463                         changeKeyMode(KEYMODE_JA_FULL_ALPHABET);
1464                         break;
1465
1466                 case KEYCODE_SWITCH_FULL_NUMBER:
1467                         /* Change mode to Full width numeric */
1468                         changeKeyMode(KEYMODE_JA_FULL_NUMBER);
1469                         break;
1470
1471                 case KEYCODE_SWITCH_HALF_KATAKANA:
1472                         /* Change mode to Half width katakana */
1473                         changeKeyMode(KEYMODE_JA_HALF_KATAKANA);
1474                         break;
1475
1476                 case KEYCODE_SWITCH_HALF_ALPHABET:
1477                         /* Change mode to Half width alphabet */
1478                         changeKeyMode(KEYMODE_JA_HALF_ALPHABET);
1479                         break;
1480
1481                 case KEYCODE_SWITCH_HALF_NUMBER:
1482                         /* Change mode to Half width numeric */
1483                         changeKeyMode(KEYMODE_JA_HALF_NUMBER);
1484                         break;
1485
1486                 case KEYCODE_SWITCH_FULL_NIKO:
1487                         /* Change mode to Full width nikotouch */
1488                         changeKeyMode(KEYMODE_JA_FULL_NIKO);
1489                         break;
1490
1491                 case KEYCODE_SELECT_CASE:
1492                         int shifted = (mShiftOn == 0) ? 1 : 0;
1493                         Keyboard newKeyboard = getShiftChangeKeyboard(shifted);
1494                         if (newKeyboard != null) {
1495                                 mShiftOn = shifted;
1496                                 changeKeyboard(newKeyboard);
1497                         }
1498                         break;
1499
1500                 case KEYCODE_JP12_SPACE:
1501                         if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) {
1502                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CONVERT));
1503                         } else {
1504                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, ' '));
1505                         }
1506                         break;
1507
1508                 case KEYCODE_EISU_KANA:
1509                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_EISU_KANA));
1510                         break;
1511
1512                 case KEYCODE_JP12_CLOSE:
1513                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_KEY,
1514                                                       new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK)));
1515                         break;
1516
1517                 case KEYCODE_JP12_LEFT:
1518                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY,
1519                                                       new KeyEvent(KeyEvent.ACTION_DOWN,
1520                                                                    KeyEvent.KEYCODE_DPAD_LEFT)));
1521                         break;
1522
1523                 case KEYCODE_JP12_RIGHT:
1524                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY,
1525                                                       new KeyEvent(KeyEvent.ACTION_DOWN,
1526                                                                    KeyEvent.KEYCODE_DPAD_RIGHT)));
1527                         break;
1528                 case KEYCODE_NOP:
1529                         break;
1530
1531                 default:
1532                         if (primaryCode >= 0) {
1533                                 if (mKeyboardView.isShifted()) {
1534                                         primaryCode = Character.toUpperCase(primaryCode);
1535                                 }
1536                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, (char)primaryCode));
1537                         }
1538                         break;
1539                 }
1540
1541                 /* update shift key's state */
1542                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
1543                         setShiftByEditorInfo();
1544                 }
1545         }
1546
1547
1548         /*****************************************
1549          * onkey nikotouch
1550          */
1551         private boolean onKeyNiko(int primaryCode, int[] keyCodes) {
1552                 Keyboard newKeyboard = null;
1553                 boolean retcode = false;
1554                 switch (primaryCode) {
1555                 case DefaultSoftKeyboard.KEYCODE_QWERTY_BACKSPACE:
1556                 case KEYCODE_JP12_BACKSPACE:
1557                         if (mNikoFirst == true) {
1558                                 resetNikoKeyboard();
1559                         }
1560                         else {
1561                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL)));
1562                         }
1563                         retcode = true;
1564                         break;
1565                 case KEYCODE_QWERTY_ENTER:
1566                 case KEYCODE_JP12_ENTER:
1567                         if (mNikoFirst == false) {
1568                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENTER)));
1569                         }
1570                         retcode = true;
1571                         break;
1572
1573                 case KEYCODE_JP12_REVERSE:
1574                         if (mNikoFirst == true) {
1575                                 resetNikoKeyboard();
1576                         }
1577                         //mWnn.mushup();
1578                         retcode = true;
1579                         break;
1580
1581                 case KEYCODE_QWERTY_KBD:
1582                 case KEYCODE_JP12_KBD:
1583                         resetNikoKeyboard();
1584                         break;
1585
1586                 case KEYCODE_JP12_EMOJI:
1587                 case KEYCODE_QWERTY_EMOJI:
1588                         if (mNikoFirst == false) {
1589                                 commitText();
1590                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_SYMBOL));
1591                         }
1592                         retcode = true;
1593                         break;
1594
1595                 case KEYCODE_JP12_SHARP:
1596                         retcode = true;
1597                         break;
1598
1599                 case KEYCODE_JP12_1:
1600                 case KEYCODE_JP12_2:
1601                 case KEYCODE_JP12_3:
1602                 case KEYCODE_JP12_4:
1603                 case KEYCODE_JP12_5:
1604                 case KEYCODE_JP12_6:
1605                 case KEYCODE_JP12_7:
1606                 case KEYCODE_JP12_8:
1607                 case KEYCODE_JP12_9:
1608                 case KEYCODE_JP12_0:
1609                         if (mNikoFirst == false) {
1610                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOUCH_OTHER_KEY));
1611                                 /* change keymap */
1612                                 int index = getTableIndex(primaryCode);
1613                                 Keyboard[][] keyList = mKeyboard[LANG_JA][mDisplayMode][KEYBOARD_12KEY][KEYBOARD_SHIFT_ON];
1614                                 if (false == mChangeYLineBellMode) {
1615                                         keyList[KEYMODE_JA_FULL_NIKO]     = mNikoKeyboard[index+1];
1616                                 }
1617                                 else{
1618                                         keyList[KEYMODE_JA_FULL_NIKO]     = mBellKeyboard[index+1];
1619                                 }
1620                                 newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_ON);
1621                                 if (newKeyboard != null) {
1622                                         mShiftOn = KEYBOARD_SHIFT_ON;
1623                                         changeKeyboard(newKeyboard);
1624                                 }
1625                                 mPrevInputKeyCode = primaryCode;
1626                                 mNikoFirst = true;
1627                         }
1628                         else{
1629                                 int col = getTableIndex(mPrevInputKeyCode);
1630                                 int row = getTableIndex(primaryCode);
1631                                 String[][] cycleTable = getCycleTable();
1632                                 if (cycleTable == null) {
1633                                         Log.e("NicoWnn", "not founds cycle table");
1634                                 }
1635                                 else{
1636                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[col * 10 + row]));
1637                                 }
1638                                 newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_OFF);
1639                                 if (newKeyboard != null) {
1640                                         mShiftOn = KEYBOARD_SHIFT_OFF;
1641                                         changeKeyboard(newKeyboard);
1642                                 }
1643                                 mNikoFirst = false;
1644                         }
1645                         retcode = true;
1646                         break;
1647
1648                 case KEYCODE_JP12_ASTER:
1649                         if (mNikoFirst == false && !mNoInput) {
1650                                 /* Processing to toggle Dakuten, Handakuten, and capital */
1651                                 HashMap replaceTable = getReplaceTable();
1652                                 if (replaceTable == null) {
1653                                         Log.e("NicoWnn", "not founds replace table");
1654                                 } else {
1655                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.REPLACE_CHAR, replaceTable));
1656                                         mPrevInputKeyCode = primaryCode;
1657                                 }
1658                         }
1659                         retcode = true;
1660                         break;
1661
1662                 case KEYCODE_JP12_SPACE:
1663                         if (mNikoFirst == false) {
1664                                 if ((mCurrentKeyMode == KEYMODE_JA_FULL_HIRAGANA) && !mNoInput) {
1665                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CONVERT));
1666                                 } else {
1667                                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_CHAR, ' '));
1668                                 }
1669                         }
1670                         retcode = true;
1671                         break;
1672
1673                 case KEYCODE_EISU_KANA:
1674                         if (mNikoFirst == false) {
1675                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.CHANGE_MODE, NicoWnnJAJP.ENGINE_MODE_EISU_KANA));
1676                         }
1677                         retcode = true;
1678                         break;
1679
1680                 case KEYCODE_JP12_CLOSE:
1681                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK)));
1682                         retcode = true;
1683                         break;
1684
1685                 case KEYCODE_JP12_LEFT:
1686                         if (mNikoFirst == false) {
1687                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_LEFT)));
1688                         }
1689                         retcode = true;
1690                         break;
1691                 case KEYCODE_JP12_RIGHT:
1692                         if (mNikoFirst == false) {
1693                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.INPUT_SOFT_KEY, new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DPAD_RIGHT)));
1694                         }
1695                         retcode = true;
1696                         break;
1697                 }
1698                 return retcode;
1699         } // onKeyNiko
1700         /*
1701          * reset nikotouch keyboard
1702          */
1703         @Override public void resetNikoKeyboard() {
1704                 Keyboard newKeyboard = getShiftChangeKeyboard(KEYBOARD_SHIFT_OFF);
1705                 if (newKeyboard != null) {
1706                         mShiftOn = KEYBOARD_SHIFT_OFF;
1707                         changeKeyboard(newKeyboard);
1708                 }
1709                 mNikoFirst = false;
1710         } // resetNikoKeyboard
1711         private void setLastNikoChar(int keycode) {
1712                 int col = getTableIndex(keycode);
1713                 String[][] cycleTable = getCycleTable();
1714                 if (cycleTable == null) {
1715                         Log.e("NicoWnn", "not founds cycle table");
1716                 }
1717                 else{
1718                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[col * 10]));
1719                 }
1720                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOUCH_OTHER_KEY));
1721         } // setLastNikoChar
1722
1723         /*************************************************
1724          * flick mode
1725          */
1726         private void onkeyFlick(int primaryCode, int[] keyCodes) {
1727                 switch (primaryCode) {
1728                 case KEYCODE_JP12_TOGGLE_MODE:
1729                 case KEYCODE_QWERTY_TOGGLE_MODE:
1730                         if (!mIsInputTypeNull) {
1731                                 nextKeyMode();
1732                         }
1733                         break;
1734                 case KEYCODE_SWITCH_FULL_HIRAGANA:
1735                         /* Change mode to Full width hiragana */
1736                         changeKeyMode(KEYMODE_JA_FULL_HIRAGANA);
1737                         break;
1738
1739                 case KEYCODE_SWITCH_FULL_KATAKANA:
1740                         /* Change mode to Full width katakana */
1741                         changeKeyMode(KEYMODE_JA_FULL_KATAKANA);
1742                         break;
1743
1744                 case KEYCODE_SWITCH_FULL_ALPHABET:
1745                         /* Change mode to Full width alphabet */
1746                         changeKeyMode(KEYMODE_JA_FULL_ALPHABET);
1747                         break;
1748
1749                 case KEYCODE_SWITCH_FULL_NUMBER:
1750                         /* Change mode to Full width numeric */
1751                         changeKeyMode(KEYMODE_JA_FULL_NUMBER);
1752                         break;
1753
1754                 case KEYCODE_SWITCH_HALF_KATAKANA:
1755                         /* Change mode to Half width katakana */
1756                         changeKeyMode(KEYMODE_JA_HALF_KATAKANA);
1757                         break;
1758
1759                 case KEYCODE_SWITCH_HALF_ALPHABET:
1760                         /* Change mode to Half width alphabet */
1761                         changeKeyMode(KEYMODE_JA_HALF_ALPHABET);
1762                         break;
1763
1764                 case KEYCODE_SWITCH_HALF_NUMBER:
1765                         /* Change mode to Half width numeric */
1766                         changeKeyMode(KEYMODE_JA_HALF_NUMBER);
1767                         break;
1768
1769                 case KEYCODE_SWITCH_FULL_NIKO:
1770                         /* Change mode to Full width nikotouch */
1771                         changeKeyMode(KEYMODE_JA_FULL_NIKO);
1772                         break;
1773                 case KEYCODE_SELECT_CASE:
1774                         int shifted = (mShiftOn == 0) ? 1 : 0;
1775                         Keyboard newKeyboard = getShiftChangeKeyboard(shifted);
1776                         if (newKeyboard != null) {
1777                                 mShiftOn = shifted;
1778                                 changeKeyboard(newKeyboard);
1779                         }
1780                         break;
1781                 case KEYCODE_NOP:
1782                         break;
1783                 }
1784                 /* update shift key's state */
1785                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
1786                         setShiftByEditorInfo();
1787                 }
1788         }
1789         /**
1790          */
1791         @Override public void onPress(int primaryCode) {
1792                 super.onPress(primaryCode);
1793                 mStockFlickCode = primaryCode;
1794         }
1795         /**
1796          */
1797         @Override public void onRelease(int primaryCode) {
1798                 super.onRelease(primaryCode);
1799
1800                 if (false == mIsEnableFlick) {
1801                         return;
1802                 }
1803                 if (mCurrentKeyMode == KEYMODE_JA_FULL_NIKO) {
1804                         return;
1805                 }
1806
1807                 if (true == mIsHookFlick) {
1808                         onKey(mStockFlickCode, null);
1809                         return;
1810                 }
1811
1812                 float getx = mReleaseX - mPressX;
1813                 float gety = mReleaseY - mPressY;
1814                 float limx = getx;
1815                 float limy = gety;
1816                 if (limx < 0.0f)  limx *= -1.0f;
1817                 if (limy < 0.0f)  limy *= -1.0f;
1818
1819                 if (limx < mFlickLimitX) {
1820                         limx = 0.0f;
1821                 }
1822                 if (limy < mFlickLimitY) {
1823                         limy = 0.0f;
1824                 }
1825                 int offset = 0;
1826                 if (limx > limy) {
1827                         // move left/right
1828                         if (getx < mFlickLimitX) {
1829                                 offset = 1;
1830                         }
1831                         else {
1832                                 offset = 3;
1833                         }
1834                 }
1835                 else if (limy > limx) {
1836                         // move up/down
1837                         if (gety < mFlickLimitY) {
1838                                 offset = 2;
1839                         }
1840                         else {
1841                                 offset = 4;
1842                         }
1843                 }
1844
1845
1846
1847                 switch (mStockFlickCode) {
1848                 case KEYCODE_JP12_1:
1849                 case KEYCODE_JP12_2:
1850                 case KEYCODE_JP12_3:
1851                 case KEYCODE_JP12_4:
1852                 case KEYCODE_JP12_5:
1853                 case KEYCODE_JP12_6:
1854                 case KEYCODE_JP12_7:
1855                 case KEYCODE_JP12_8:
1856                 case KEYCODE_JP12_9:
1857                 case KEYCODE_JP12_0:
1858                         int col = getTableIndex(mStockFlickCode);
1859                         String[][] cycleTable = getCycleTable();
1860                         if (cycleTable == null) {
1861                                 Log.e("NicoWnn", "not founds cycle table");
1862                         }
1863                         else{
1864                                 mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOGGLE_CHAR, cycleTable[col * 10 + offset]));
1865                         }
1866                         mWnn.onEvent(new NicoWnnEvent(NicoWnnEvent.TOUCH_OTHER_KEY));
1867                         break;
1868                 default:
1869                         onKey(mStockFlickCode, null);
1870                         return;
1871                 }
1872                 /* update shift key's state */
1873                 if (!mCapsLock && (primaryCode != DefaultSoftKeyboard.KEYCODE_QWERTY_SHIFT)) {
1874                         setShiftByEditorInfo();
1875                 }
1876         } // onRelease
1877 }