Added initial key override support. Use at own risk.

keymap.txt.sample

@@ -0,0 +1,10 @@
+DPAD_CENTER 23
+DPAD_DOWN 20
+DPAD_UP 19
+DPAD_LEFT 21
+DPAD_RIGHT 22
+SOFT_RIGHT 2
+SOFT_LEFT 1
+DEL 67
+BACK 4
+ENTER 66

res/values-de/strings-german.xml

@@ -66,6 +66,7 @@
 	<string name="pref_restore_nofile">Fehler: Sicherungsdatei nicht gefunden.</string>
 	<string name="pref_nuke_warn">Warnung: Dies wird das gesamte Wörterbuch löschen. Fortfahren?</string>
 	<string name="pref_nuke_title">IME-Wörterbuch löschen</string>
+	<string name="pref_reloadKeys">Force reload of key overrides</string>
 
 	<string name="hello_world">Hallo Welt!</string>
 

res/values-ru/strings.xml

@@ -61,6 +61,7 @@
 	<string name="pref_mode_notify_subtitle">Используется для озвучивания изменения режима ввода.</string>
 	<string name="pref_mode_notify">Режим уведомления</string>
 	<string name="database_settings_notready">Database unavailable. Using default settings.</string>
+	<string name="pref_reloadKeys">Force reload of key overrides</string>
 
     <string name="title_activity_add_word">Добавить слово</string>
     <string name="traditionalt9_settings">Traditional T9 настройки</string>

res/values/strings.xml

@@ -68,6 +68,7 @@
 	<string name="pref_restore_nofile">Error: Backup file not found.</string>
 	<string name="pref_nuke_warn">Warning: This will delete your entire dictionary. Do you wish to continue?</string>
 	<string name="pref_nuke_title">Nuke IME dictionary</string>
+	<string name="pref_reloadKeys">Force reload of key overrides</string>
 
 	<string name="hello_world">Hello world!</string>
 

res/xml/prefs.xml

@@ -26,4 +26,5 @@
 	<Setting title="@string/pref_nukedict" id="nukedict"/>
 	<Setting title="@string/pref_backupdict" id="backupdict"/>
 	<Setting title="@string/pref_restoredict" id="restoredict"/>
+	<Setting title="@string/pref_reloadKeys" id="reloadKeys"/>
 </Settings>

src/org/nyanya/android/traditionalt9/KeyMap.java

@@ -0,0 +1,84 @@
+package org.nyanya.android.traditionalt9;
+
+import android.os.Environment;
+import android.util.Log;
+import android.view.KeyEvent;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class KeyMap {
+	public static final String keymapfname = "keymap.txt";
+
+	public static int DPAD_CENTER = KeyEvent.KEYCODE_DPAD_CENTER;
+	public static int DPAD_DOWN = KeyEvent.KEYCODE_DPAD_DOWN;
+	public static int DPAD_UP = KeyEvent.KEYCODE_DPAD_UP;
+	public static int DPAD_LEFT = KeyEvent.KEYCODE_DPAD_LEFT;
+	public static int DPAD_RIGHT = KeyEvent.KEYCODE_DPAD_RIGHT;
+	public static int SOFT_RIGHT = KeyEvent.KEYCODE_SOFT_RIGHT;
+	public static int SOFT_LEFT = KeyEvent.KEYCODE_SOFT_LEFT;
+	public static int DEL = KeyEvent.KEYCODE_DEL;
+	public static int BACK = KeyEvent.KEYCODE_BACK;
+	public static int ENTER = KeyEvent.KEYCODE_ENTER;
+
+	static {
+		setKeys();
+	}
+
+	public static void setKeys() {
+		// check storage
+		if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(Environment.getExternalStorageState())
+				|| Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
+			// check for file
+			if ((new File(new File(Environment.getExternalStorageDirectory(), TraditionalT9Settings.sddir),
+					keymapfname)).exists()) {
+				BufferedReader br = null;
+				Log.d("KeyMap", "Attemping to load keys");
+				try {
+					br = new BufferedReader(new FileReader(new File(
+							new File(Environment.getExternalStorageDirectory(), TraditionalT9Settings.sddir), keymapfname)));
+					String line;
+					try {
+						while ((line = br.readLine()) != null) {
+							String[] ws = line.split(" ");
+							if (ws.length != 2) {continue;}
+							try {
+								if (ws[0].equals("DPAD_CENTER")) {
+									DPAD_CENTER = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("DPAD_DOWN")) {
+									DPAD_DOWN = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("DPAD_UP")) {
+									DPAD_UP = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("DPAD_LEFT")) {
+									DPAD_LEFT = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("DPAD_RIGHT")) {
+									DPAD_RIGHT = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("SOFT_RIGHT")) {
+									SOFT_RIGHT = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("SOFT_LEFT")) {
+									SOFT_LEFT = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("DEL")) {
+									DEL = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("BACK")) {
+									BACK = Integer.parseInt(ws[1]);
+								} else if (ws[0].equals("ENTER")) {
+									ENTER = Integer.parseInt(ws[1]);
+								}
+							} catch (NumberFormatException _ignore) {
+								Log.w("T9.KeyMap", "Invalid number found");
+							}
+						}
+						Log.d("KeyMap", "Done.");
+					} catch (IOException _ignore) {
+						Log.e("T9.KeyMap", "Error while reading line.");
+						try { br.close(); }
+						catch (IOException ignored) {}
+					}
+				} catch (FileNotFoundException ignored) {	}
+			}
+		}
+	}
+}

src/org/nyanya/android/traditionalt9/TraditionalT9.java

@@ -488,41 +488,39 @@ public class TraditionalT9 extends InputMethodService implements
 				keyCode = KeyEvent.KEYCODE_STAR;
 				break;
 			case 72:
-				keyCode = KeyEvent.KEYCODE_SOFT_RIGHT;
+				keyCode = KeyMap.SOFT_RIGHT;
 				break;
 			case 71:
-				keyCode = KeyEvent.KEYCODE_SOFT_LEFT;
+				keyCode = KeyMap.SOFT_LEFT;
 				break;
 		}
 
-		switch (keyCode) {
+		if (keyCode == KeyMap.DPAD_CENTER) {
-			case KeyEvent.KEYCODE_DPAD_CENTER:
+			if (interfacehandler != null) {
-				if (interfacehandler != null) {
+				interfacehandler.setPressed(keyCode, true);
-					interfacehandler.setPressed(keyCode, true);
+			} // pass-through
-				} // pass-through
-			case KeyEvent.KEYCODE_DPAD_DOWN:
-			case KeyEvent.KEYCODE_DPAD_UP:
-			case KeyEvent.KEYCODE_DPAD_LEFT:
-			case KeyEvent.KEYCODE_DPAD_RIGHT:
-				if (mEditing == EDITING_NOSHOW) {
-					return false;
-				}
-				return handleDPAD(keyCode, event, true);
 
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
-			case KeyEvent.KEYCODE_SOFT_LEFT:
-				if (!isInputViewShown()) {
-					return super.onKeyDown(keyCode, event);
-				}
-				break;
 
-			case KeyEvent.KEYCODE_DEL:
+			if (mEditing == EDITING_NOSHOW) {
-				// Special handling of the delete key: if we currently are
+				return false;
-				// composing text for the user, we want to modify that instead
+			}
-				// of let the application to the delete itself.
+			return handleDPAD(keyCode, event, true);
-				// if (mComposing.length() > 0) {
+		} else if (keyCode == KeyMap.DPAD_DOWN || keyCode == KeyMap.DPAD_UP || keyCode == KeyMap.DPAD_LEFT || keyCode == KeyMap.DPAD_RIGHT) {
-				onKey(keyCode, null);
+			if (mEditing == EDITING_NOSHOW) {
-				return true;
+				return false;
+			}
+			return handleDPAD(keyCode, event, true);
+		} else if (keyCode == KeyMap.SOFT_RIGHT || keyCode == KeyMap.SOFT_LEFT) {
+			if (!isInputViewShown()) {
+				return super.onKeyDown(keyCode, event);
+			}
+
+		} else if (keyCode == KeyMap.DEL) {// Special handling of the delete key: if we currently are
+			// composing text for the user, we want to modify that instead
+			// of let the application to the delete itself.
+			// if (mComposing.length() > 0) {
+			onKey(keyCode, null);
+			return true;
 			// }
 			// break;
 		}
@@ -534,45 +532,31 @@ public class TraditionalT9 extends InputMethodService implements
 		if (mKeyMode == MODE_TEXT) {
 			t9releasehandler.removeCallbacks(mt9release);
 		}
-		switch (keyCode) {
+		if (keyCode == KeyMap.BACK) {// The InputMethodService already takes care of the back
-			case KeyEvent.KEYCODE_BACK:
+			// key for us, to dismiss the input method if it is shown.
-				// The InputMethodService already takes care of the back
+			// but we will manage it ourselves because native Android handling
-				// key for us, to dismiss the input method if it is shown.
+			// of the input view is ... flakey at best.
-				// but we will manage it ourselves because native Android handling
+			// Log.d("onKeyDown", "back pres");
-				// of the input view is ... flakey at best.
+			return isInputViewShown();
-				// Log.d("onKeyDown", "back pres");
+		} else if (keyCode == KeyMap.ENTER) {// Let the underlying text editor always handle these.
-				return isInputViewShown();
+			return false;
-
-			case KeyEvent.KEYCODE_ENTER:
-				// Let the underlying text editor always handle these.
-				return false;
 
 			// special case for softkeys
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
+		} else if (keyCode == KeyMap.SOFT_RIGHT || keyCode == KeyMap.SOFT_LEFT) {
-			case KeyEvent.KEYCODE_SOFT_LEFT:
+			if (interfacehandler != null) {
-				if (interfacehandler != null) {
+				interfacehandler.setPressed(keyCode, true);
-					interfacehandler.setPressed(keyCode, true);
+			}
-				}
 			// pass-through
-			case KeyEvent.KEYCODE_0:
+
-			case KeyEvent.KEYCODE_1:
+
-			case KeyEvent.KEYCODE_2:
+			event.startTracking();
-			case KeyEvent.KEYCODE_3:
+			return true;
-			case KeyEvent.KEYCODE_4:
+		} else if (keyCode == KeyEvent.KEYCODE_0 || keyCode == KeyEvent.KEYCODE_1 || keyCode == KeyEvent.KEYCODE_2 || keyCode == KeyEvent.KEYCODE_3 || keyCode == KeyEvent.KEYCODE_4 || keyCode == KeyEvent.KEYCODE_5 || keyCode == KeyEvent.KEYCODE_6 || keyCode == KeyEvent.KEYCODE_7 || keyCode == KeyEvent.KEYCODE_8 || keyCode == KeyEvent.KEYCODE_9 || keyCode == KeyEvent.KEYCODE_POUND || keyCode == KeyEvent.KEYCODE_STAR || keyCode == 94) {
-			case KeyEvent.KEYCODE_5:
+			event.startTracking();
-			case KeyEvent.KEYCODE_6:
+			return true;
-			case KeyEvent.KEYCODE_7:
+		} else {// KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD).getNumber(keyCode)
-			case KeyEvent.KEYCODE_8:
+			// Log.w("onKeyDown", "Unhandled Key: " + keyCode + "(" +
-			case KeyEvent.KEYCODE_9:
+			// event.toString() + ")");
-			case KeyEvent.KEYCODE_POUND:
-			case KeyEvent.KEYCODE_STAR:
-			case 94:
-				event.startTracking();
-				return true;
-			default:
-				// KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD).getNumber(keyCode)
-				// Log.w("onKeyDown", "Unhandled Key: " + keyCode + "(" +
-				// event.toString() + ")");
 		}
 		Log.w("onKeyDown", "Unhandled Key: " + keyCode + "(" + event.toString() + ")");
 		commitReset();
@@ -605,52 +589,51 @@ public class TraditionalT9 extends InputMethodService implements
 				keyCode = KeyEvent.KEYCODE_STAR;
 				break;
 			case 72:
-				keyCode = KeyEvent.KEYCODE_SOFT_RIGHT;
+				keyCode = KeyMap.SOFT_RIGHT;
 				break;
 			case 71:
-				keyCode = KeyEvent.KEYCODE_SOFT_LEFT;
+				keyCode = KeyMap.SOFT_LEFT;
 				break;
 		}
 
 		// Log.d("onLongPress", "LONG PRESS: " + keyCode);
 		// HANDLE SPECIAL KEYS
-		switch (keyCode) {
+		if (keyCode == KeyEvent.KEYCODE_POUND) {
-			case KeyEvent.KEYCODE_POUND:
+			commitReset();
-				commitReset();
+			// do default action or insert new line
-				// do default action or insert new line
+			if (!sendDefaultEditorAction(true)) {
-				if (!sendDefaultEditorAction(true)) {
+				onText("\n");
-					onText("\n");
+			}
+			return true;
+		} else if (keyCode == KeyEvent.KEYCODE_STAR) {
+			if (mKeyMode != MODE_NUM) {
+				if (mLangsAvailable.length > 1) {
+					nextLang();
+				} else {
+					showSmileyPage(); // TODO: replace with lang select if lang thing
 				}
 				return true;
-			case KeyEvent.KEYCODE_STAR:
+			}
-				if (mKeyMode != MODE_NUM) {
+
-					if (mLangsAvailable.length > 1){
+		} else if (keyCode == KeyMap.SOFT_LEFT) {
-						nextLang();
+			if (interfacehandler != null) {
-					} else {
+				interfacehandler.setPressed(keyCode, false);
-						showSmileyPage(); // TODO: replace with lang select if lang thing
+			}
-					}
+			if (mKeyMode == MODE_LANG) {
-					return true;
+				if (mWordFound) {
+					showAddWord();
+				} else {
+					showSymbolPage();
 				}
-				break;
+			}
-			case KeyEvent.KEYCODE_SOFT_LEFT:
+
-				if (interfacehandler != null) {
+		} else if (keyCode == KeyMap.SOFT_RIGHT) {
-					interfacehandler.setPressed(keyCode, false);
+			if (interfacehandler != null) {
-				}
+				interfacehandler.setPressed(keyCode, false);
-				if (mKeyMode == MODE_LANG) {
+			}
-					if (mWordFound) {
+			launchOptions();
-						showAddWord();
+			// show Options
-					} else {
+			return true;
-						showSymbolPage();
-					}
-				}
-				break;
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
-				if (interfacehandler != null) {
-					interfacehandler.setPressed(keyCode, false);
-				}
-				launchOptions();
-				// show Options
-				return true;
 		}
 		if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
 			if (mKeyMode == MODE_LANG) {
@@ -699,92 +682,86 @@ public class TraditionalT9 extends InputMethodService implements
 				keyCode = KeyEvent.KEYCODE_STAR;
 				break;
 			case 72:
-				keyCode = KeyEvent.KEYCODE_SOFT_RIGHT;
+				keyCode = KeyMap.SOFT_RIGHT;
 				break;
 			case 71:
-				keyCode = KeyEvent.KEYCODE_SOFT_LEFT;
+				keyCode = KeyMap.SOFT_LEFT;
 				break;
 		}
 
-		switch (keyCode) {
+		if (keyCode == KeyMap.DPAD_CENTER) {
-			case KeyEvent.KEYCODE_DPAD_CENTER:
+			if (interfacehandler != null) {
-				if (interfacehandler != null) {
+				interfacehandler.setPressed(keyCode, false);
-					interfacehandler.setPressed(keyCode, false);
+			}
-				}
+			if (mEditing == EDITING_NOSHOW) {
-			case KeyEvent.KEYCODE_DPAD_DOWN:
+				return false;
-			case KeyEvent.KEYCODE_DPAD_UP:
+			}
-			case KeyEvent.KEYCODE_DPAD_LEFT:
+			return handleDPAD(keyCode, event, false);
-			case KeyEvent.KEYCODE_DPAD_RIGHT:
+		} else if (keyCode == KeyMap.DPAD_DOWN || keyCode == KeyMap.DPAD_UP || keyCode == KeyMap.DPAD_LEFT || keyCode == KeyMap.DPAD_RIGHT) {
-				if (mEditing == EDITING_NOSHOW) {
+			if (mEditing == EDITING_NOSHOW) {
-					return false;
+				return false;
-				}
+			}
-				return handleDPAD(keyCode, event, false);
+			return handleDPAD(keyCode, event, false);
+		} else if (keyCode == KeyMap.SOFT_RIGHT || keyCode == KeyMap.SOFT_LEFT) {
+			if (!isInputViewShown()) {
+				return super.onKeyDown(keyCode, event);
+			}
 
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
-			case KeyEvent.KEYCODE_SOFT_LEFT:
-				if (!isInputViewShown()) {
-					return super.onKeyDown(keyCode, event);
-				}
-				break;
 		}
 
 		if (event.isCanceled()) {
 			return true;
 		}
 
-		switch (keyCode) {
+		if (keyCode == KeyMap.BACK) {
-			case KeyEvent.KEYCODE_BACK:
+			if (isInputViewShown()) {
-				if (isInputViewShown()) {
+				hideWindow();
-					hideWindow();
-					return true;
-				}
-				return false;
-			case KeyEvent.KEYCODE_DEL:
 				return true;
-			case KeyEvent.KEYCODE_ENTER:
+			}
-				return false;
+			return false;
+		} else if (keyCode == KeyMap.DEL) {
+			return true;
+		} else if (keyCode == KeyMap.ENTER) {
+			return false;
 
 			// special case for softkeys
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
+		} else if (keyCode == KeyMap.SOFT_RIGHT || keyCode == KeyMap.SOFT_LEFT) {// if (mAddingWord){
-			case KeyEvent.KEYCODE_SOFT_LEFT:
+			// Log.d("onKeyUp", "key: " + keyCode + " skip: " +
-				// if (mAddingWord){
+			// mAddingSkipInput);
-				// Log.d("onKeyUp", "key: " + keyCode + " skip: " +
+			// if (mAddingSkipInput) {
-				// mAddingSkipInput);
+			// //mAddingSkipInput = false;
-				// if (mAddingSkipInput) {
+			// return true;
-				// //mAddingSkipInput = false;
+			// }
-				// return true;
+			// }
-				// }
+			if (interfacehandler != null) {
-				// }
+				interfacehandler.setPressed(keyCode, false);
-				if (interfacehandler != null) {
+			}
-					interfacehandler.setPressed(keyCode, false);
-				}
 			// pass-through
-			case KeyEvent.KEYCODE_0:
+
-			case KeyEvent.KEYCODE_1:
+
-			case KeyEvent.KEYCODE_2:
-			case KeyEvent.KEYCODE_3:
-			case KeyEvent.KEYCODE_4:
-			case KeyEvent.KEYCODE_5:
-			case KeyEvent.KEYCODE_6:
-			case KeyEvent.KEYCODE_7:
-			case KeyEvent.KEYCODE_8:
-			case KeyEvent.KEYCODE_9:
-			case KeyEvent.KEYCODE_POUND:
-			case KeyEvent.KEYCODE_STAR:
-			case 94:
 			//case KeyEvent.KEYCODE_FOCUS:
-				// if (!isInputViewShown()){
+			// if (!isInputViewShown()){
-				// Log.d("onKeyUp", "showing window.");
+			// Log.d("onKeyUp", "showing window.");
-				// //showWindow(true);
+			// //showWindow(true);
-				// }
+			// }
-				if (! isInputViewShown ()) {
+			if (!isInputViewShown()) {
-					showWindow (true);
+				showWindow(true);
-				}
+			}
-				onKey(keyCode, null);
+			onKey(keyCode, null);
-				return true;
+			return true;
-			default:
+		} else if (keyCode == KeyEvent.KEYCODE_0 || keyCode == KeyEvent.KEYCODE_1 || keyCode == KeyEvent.KEYCODE_2
-				// KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD).getNumber(keyCode)
+				|| keyCode == KeyEvent.KEYCODE_3 || keyCode == KeyEvent.KEYCODE_4 || keyCode == KeyEvent.KEYCODE_5 || keyCode == KeyEvent.KEYCODE_6 || keyCode == KeyEvent.KEYCODE_7 || keyCode == KeyEvent.KEYCODE_8 || keyCode == KeyEvent.KEYCODE_9 || keyCode == KeyEvent.KEYCODE_POUND || keyCode == KeyEvent.KEYCODE_STAR || keyCode == 94) {//case KeyEvent.KEYCODE_FOCUS:
-				Log.w("onKeyUp", "Unhandled Key: " + keyCode + "(" + event.toString() + ")");
+			// if (!isInputViewShown()){
+			// Log.d("onKeyUp", "showing window.");
+			// //showWindow(true);
+			// }
+			if (!isInputViewShown()) {
+				showWindow(true);
+			}
+			onKey(keyCode, null);
+			return true;
+		} else {// KeyCharacterMap.load(KeyCharacterMap.BUILT_IN_KEYBOARD).getNumber(keyCode)
+			Log.w("onKeyUp", "Unhandled Key: " + keyCode + "(" + event.toString() + ")");
 		}
 		commitReset();
 		return super.onKeyUp(keyCode, event);
@@ -857,41 +834,40 @@ public class TraditionalT9 extends InputMethodService implements
 		// Log.d("OnKey", "pri: " + keyCode);
 		// Log.d("onKey", "START Cm: " + mCapsMode);
 		// HANDLE SPECIAL KEYS
-		switch (keyCode) {
+		if (keyCode == KeyMap.DEL) {
-			case KeyEvent.KEYCODE_DEL:
+			handleBackspace();
-				handleBackspace();
+
-				break;
 			// change case
-			case KeyEvent.KEYCODE_STAR:
+		} else if (keyCode == KeyEvent.KEYCODE_STAR) {
-				if (mKeyMode == MODE_NUM) {
+			if (mKeyMode == MODE_NUM) {
-					handleCharacter(KeyEvent.KEYCODE_STAR);
+				handleCharacter(KeyEvent.KEYCODE_STAR);
-				} else {
+			} else {
-					handleShift();
+				handleShift();
-				}
+			}
-				break;
+
-			case KeyEvent.KEYCODE_BACK:
+		} else if (keyCode == KeyMap.BACK) {
-				handleClose();
+			handleClose();
-				break;
+
 			// space
-			case KeyEvent.KEYCODE_POUND:
+		} else if (keyCode == KeyEvent.KEYCODE_POUND) {
-				handleCharacter(KeyEvent.KEYCODE_POUND);
+			handleCharacter(KeyEvent.KEYCODE_POUND);
-				break;
+
-			case KeyEvent.KEYCODE_SOFT_LEFT:
+		} else if (keyCode == KeyMap.SOFT_LEFT) {
-				if (mWordFound) {
+			if (mWordFound) {
-					showSymbolPage();
+				showSymbolPage();
-				} else {
+			} else {
-					showAddWord();
+				showAddWord();
-				}
+			}
-				break;
+
-			case KeyEvent.KEYCODE_SOFT_RIGHT:
+		} else if (keyCode == KeyMap.SOFT_RIGHT) {
-				nextKeyMode();
+			nextKeyMode();
-				break;
+
-			default:
+		} else {
-				if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
+			if (keyCode >= KeyEvent.KEYCODE_0 && keyCode <= KeyEvent.KEYCODE_9) {
-					handleCharacter(keyCode);
+				handleCharacter(keyCode);
-				} else {
+			} else {
-					Log.e("onKey", "This shouldn't happen, unknown key");
+				Log.e("onKey", "This shouldn't happen, unknown key");
-				}
+			}
 		}
 		// Log.d("onKey", "END Cm: " + mCapsMode);
 	}
@@ -1224,36 +1200,32 @@ public class TraditionalT9 extends InputMethodService implements
 				return super.onKeyUp(keyCode, event);
 			} else {
 				if (mKeyMode != MODE_NUM && mComposing.length() > 0) {
-					switch (keyCode) {
+					if (keyCode == KeyMap.DPAD_DOWN) {
-						case KeyEvent.KEYCODE_DPAD_DOWN:
+						mCandidateView.scrollSuggestion(1);
-							mCandidateView.scrollSuggestion(1);
+						getCurrentInputConnection().setComposingText(mSuggestionStrings.get(mCandidateView.mSelectedIndex), 1);
-							getCurrentInputConnection().setComposingText(mSuggestionStrings.get(mCandidateView.mSelectedIndex), 1);
+						return true;
-							return true;
+					} else if (keyCode == KeyMap.DPAD_UP) {
-						case KeyEvent.KEYCODE_DPAD_UP:
+						mCandidateView.scrollSuggestion(-1);
-							mCandidateView.scrollSuggestion(-1);
+						getCurrentInputConnection().setComposingText(mSuggestionStrings.get(mCandidateView.mSelectedIndex), 1);
-							getCurrentInputConnection().setComposingText(mSuggestionStrings.get(mCandidateView.mSelectedIndex), 1);
+						return true;
-							return true;
+					} else if (keyCode == KeyMap.DPAD_LEFT || keyCode == KeyMap.DPAD_RIGHT) {
-						case KeyEvent.KEYCODE_DPAD_LEFT:
+						if (mKeyMode == MODE_LANG) {
-						case KeyEvent.KEYCODE_DPAD_RIGHT:
+							commitTyped();
-							if (mKeyMode == MODE_LANG) {
+						} else if (mKeyMode == MODE_TEXT) {
-								commitTyped();
+							commitReset();
-							} else if (mKeyMode == MODE_TEXT) {
+						}
-								commitReset();
+						// getCurrentInputConnection().sendKeyEvent(mDPADkeyEvent);
-							}
+						// return super.onKeyUp(keyCode, event);
-							// getCurrentInputConnection().sendKeyEvent(mDPADkeyEvent);
+						return true;
-							// return super.onKeyUp(keyCode, event);
-							return true;
 					}
 				}
-				switch (keyCode) {
+				if (keyCode == KeyMap.DPAD_CENTER) {
-					case KeyEvent.KEYCODE_DPAD_CENTER:
+					handleMidButton();
-						handleMidButton();
+					return true;
-						return true;
+				} else {// Send stored event to input connection then pass current
-					default:
+					// event onto super
-						// Send stored event to input connection then pass current
+					getCurrentInputConnection().sendKeyEvent(mDPADkeyEvent);
-						// event onto super
+					return super.onKeyUp(keyCode, event);
-						getCurrentInputConnection().sendKeyEvent(mDPADkeyEvent);
-						return super.onKeyUp(keyCode, event);
 				}
 			}
 		}
@@ -1295,7 +1267,6 @@ public class TraditionalT9 extends InputMethodService implements
 	}
 
 	private void modeNotify(String s) {
-		Log.d("T9.modeNotify", "Notifying:"+s);
 		modeNotification.setText(s);
 		modeNotification.show();
 		modeNotification.cancel(); 	// TODO: This will not always hide the Toast.

src/org/nyanya/android/traditionalt9/TraditionalT9Settings.java

@@ -720,6 +720,8 @@ public class TraditionalT9Settings extends ListActivity implements
 			backupDict();
 		else if (s.id.equals("restoredict"))
 			restoreDict();
+		else if (s.id.equals("reloadKeys"))
+			KeyMap.setKeys();
 		else
 			s.clicked(mContext);
 	}