core/java/android/widget/DialerFilter.java - platform/frameworks/base.git - Git at Google

 /*
  * Copyright (C) 2006 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.widget;

 import android.content.Context;
 import android.view.KeyEvent;
 import android.text.Editable;
 import android.text.InputFilter;
 import android.text.Selection;
 import android.text.Spannable;
 import android.text.Spanned;
 import android.text.TextWatcher;
 import android.text.method.DialerKeyListener;
 import android.text.method.KeyListener;
 import android.text.method.TextKeyListener;
 import android.util.AttributeSet;
 import android.view.View;
 import android.graphics.Rect;


 public class DialerFilter extends RelativeLayout
 {
     public DialerFilter(Context context) {
         super(context);
     }

     public DialerFilter(Context context, AttributeSet attrs) {
         super(context, attrs);
     }

     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();

         // Setup the filter view
         mInputFilters = new InputFilter[] { new InputFilter.AllCaps() };

         mHint = (EditText) findViewById(com.android.internal.R.id.hint);
         if (mHint == null) {
             throw new IllegalStateException("DialerFilter must have a child EditText named hint");
         }
         mHint.setFilters(mInputFilters);

         mLetters = mHint;
         mLetters.setKeyListener(TextKeyListener.getInstance());
         mLetters.setMovementMethod(null);
         mLetters.setFocusable(false);

         // Setup the digits view
         mPrimary = (EditText) findViewById(com.android.internal.R.id.primary);
         if (mPrimary == null) {
             throw new IllegalStateException("DialerFilter must have a child EditText named primary");
         }
         mPrimary.setFilters(mInputFilters);

         mDigits = mPrimary;
         mDigits.setKeyListener(DialerKeyListener.getInstance());
         mDigits.setMovementMethod(null);
         mDigits.setFocusable(false);

         // Look for an icon
         mIcon = (ImageView) findViewById(com.android.internal.R.id.icon);

         // Setup focus & highlight for this view
         setFocusable(true);

         // XXX Force the mode to QWERTY for now, since 12-key isn't supported
         mIsQwerty = true;
         setMode(DIGITS_AND_LETTERS);
     }

     /**
      * Only show the icon view when focused, if there is one.
      */
     @Override
     protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
         super.onFocusChanged(focused, direction, previouslyFocusedRect);

         if (mIcon != null) {
             mIcon.setVisibility(focused ? View.VISIBLE : View.GONE);
         }
     }


     public boolean isQwertyKeyboard() {
         return mIsQwerty;
     }

     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
         boolean handled = false;

         switch (keyCode) {
             case KeyEvent.KEYCODE_DPAD_UP:
             case KeyEvent.KEYCODE_DPAD_DOWN:
             case KeyEvent.KEYCODE_DPAD_LEFT:
             case KeyEvent.KEYCODE_DPAD_RIGHT:
             case KeyEvent.KEYCODE_ENTER:
             case KeyEvent.KEYCODE_DPAD_CENTER:
                 break;

             case KeyEvent.KEYCODE_DEL:
                 switch (mMode) {
                     case DIGITS_AND_LETTERS:
                         handled = mDigits.onKeyDown(keyCode, event);
                         handled &= mLetters.onKeyDown(keyCode, event);
                         break;

                     case DIGITS_AND_LETTERS_NO_DIGITS:
                         handled = mLetters.onKeyDown(keyCode, event);
                         if (mLetters.getText().length() == mDigits.getText().length()) {
                             setMode(DIGITS_AND_LETTERS);
                         }
                         break;

                     case DIGITS_AND_LETTERS_NO_LETTERS:
                         if (mDigits.getText().length() == mLetters.getText().length()) {
                             mLetters.onKeyDown(keyCode, event);
                             setMode(DIGITS_AND_LETTERS);
                         }
                         handled = mDigits.onKeyDown(keyCode, event);
                         break;

                     case DIGITS_ONLY:
                         handled = mDigits.onKeyDown(keyCode, event);
                         break;

                     case LETTERS_ONLY:
                         handled = mLetters.onKeyDown(keyCode, event);
                         break;
                 }
                 break;

             default:
                 //mIsQwerty = msg.getKeyIsQwertyKeyboard();

                 switch (mMode) {
                     case DIGITS_AND_LETTERS:
                         handled = mLetters.onKeyDown(keyCode, event);

                         // pass this throw so the shift state is correct (for example,
                         // on a standard QWERTY keyboard, * and 8 are on the same key)
                         if (KeyEvent.isModifierKey(keyCode)) {
                             mDigits.onKeyDown(keyCode, event);
                             handled = true;
                             break;
                         }

                         // Only check to see if the digit is valid if the key is a printing key
                         // in the TextKeyListener. This prevents us from hiding the digits
                         // line when keys like UP and DOWN are hit.
                         // XXX note that KEYCODE_TAB is special-cased here for
                         // devices that share tab and 0 on a single key.
                         boolean isPrint = event.isPrintingKey();
                         if (isPrint || keyCode == KeyEvent.KEYCODE_SPACE
                                 || keyCode == KeyEvent.KEYCODE_TAB) {
                             char c = event.getMatch(DialerKeyListener.CHARACTERS);
                             if (c != 0) {
                                 handled &= mDigits.onKeyDown(keyCode, event);
                             } else {
                                 setMode(DIGITS_AND_LETTERS_NO_DIGITS);
                             }
                         }
                         break;

                     case DIGITS_AND_LETTERS_NO_LETTERS:
                     case DIGITS_ONLY:
                         handled = mDigits.onKeyDown(keyCode, event);
                         break;

                     case DIGITS_AND_LETTERS_NO_DIGITS:
                     case LETTERS_ONLY:
                         handled = mLetters.onKeyDown(keyCode, event);
                         break;
                 }
         }

         if (!handled) {
             return super.onKeyDown(keyCode, event);
         } else {
             return true;
         }
     }

     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
         boolean a = mLetters.onKeyUp(keyCode, event);
         boolean b = mDigits.onKeyUp(keyCode, event);
         return a || b;
     }

     public int getMode() {
         return mMode;
     }

     /**
      * Change the mode of the widget.
      *
      * @param newMode The mode to switch to.
      */
     public void setMode(int newMode) {
         switch (newMode) {
             case DIGITS_AND_LETTERS:
                 makeDigitsPrimary();
                 mLetters.setVisibility(View.VISIBLE);
                 mDigits.setVisibility(View.VISIBLE);
                 break;

             case DIGITS_ONLY:
                 makeDigitsPrimary();
                 mLetters.setVisibility(View.GONE);
                 mDigits.setVisibility(View.VISIBLE);
                 break;

             case LETTERS_ONLY:
                 makeLettersPrimary();
                 mLetters.setVisibility(View.VISIBLE);
                 mDigits.setVisibility(View.GONE);
                 break;

             case DIGITS_AND_LETTERS_NO_LETTERS:
                 makeDigitsPrimary();
                 mLetters.setVisibility(View.INVISIBLE);
                 mDigits.setVisibility(View.VISIBLE);
                 break;

             case DIGITS_AND_LETTERS_NO_DIGITS:
                 makeLettersPrimary();
                 mLetters.setVisibility(View.VISIBLE);
                 mDigits.setVisibility(View.INVISIBLE);
                 break;

         }
         int oldMode = mMode;
         mMode = newMode;
         onModeChange(oldMode, newMode);
     }

     private void makeLettersPrimary() {
         if (mPrimary == mDigits) {
             swapPrimaryAndHint(true);
         }
     }

     private void makeDigitsPrimary() {
         if (mPrimary == mLetters) {
             swapPrimaryAndHint(false);
         }
     }

     private void swapPrimaryAndHint(boolean makeLettersPrimary) {
         Editable lettersText = mLetters.getText();
         Editable digitsText = mDigits.getText();
         KeyListener lettersInput = mLetters.getKeyListener();
         KeyListener digitsInput = mDigits.getKeyListener();

         if (makeLettersPrimary) {
             mLetters = mPrimary;
             mDigits = mHint;
         } else {
             mLetters = mHint;
             mDigits = mPrimary;
         }

         mLetters.setKeyListener(lettersInput);
         mLetters.setText(lettersText);
         lettersText = mLetters.getText();
         Selection.setSelection(lettersText, lettersText.length());

         mDigits.setKeyListener(digitsInput);
         mDigits.setText(digitsText);
         digitsText = mDigits.getText();
         Selection.setSelection(digitsText, digitsText.length());

         // Reset the filters
         mPrimary.setFilters(mInputFilters);
         mHint.setFilters(mInputFilters);
     }


     public CharSequence getLetters() {
         if (mLetters.getVisibility() == View.VISIBLE) {
             return mLetters.getText();
         } else {
             return "";
         }
     }

     public CharSequence getDigits() {
         if (mDigits.getVisibility() == View.VISIBLE) {
             return mDigits.getText();
         } else {
             return "";
         }
     }

     public CharSequence getFilterText() {
         if (mMode != DIGITS_ONLY) {
             return getLetters();
         } else {
             return getDigits();
         }
     }

     public void append(String text) {
         switch (mMode) {
             case DIGITS_AND_LETTERS:
                 mDigits.getText().append(text);
                 mLetters.getText().append(text);
                 break;

             case DIGITS_AND_LETTERS_NO_LETTERS:
             case DIGITS_ONLY:
                 mDigits.getText().append(text);
                 break;

             case DIGITS_AND_LETTERS_NO_DIGITS:
             case LETTERS_ONLY:
                 mLetters.getText().append(text);
                 break;
         }
     }

     /**
      * Clears both the digits and the filter text.
      */
     public void clearText() {
         Editable text;

         text = mLetters.getText();
         text.clear();

         text = mDigits.getText();
         text.clear();

         // Reset the mode based on the hardware type
         if (mIsQwerty) {
             setMode(DIGITS_AND_LETTERS);
         } else {
             setMode(DIGITS_ONLY);
         }
     }

     public void setLettersWatcher(TextWatcher watcher) {
         CharSequence text = mLetters.getText();
         Spannable span = (Spannable)text;
         span.setSpan(watcher, 0, text.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
     }

     public void setDigitsWatcher(TextWatcher watcher) {
         CharSequence text = mDigits.getText();
         Spannable span = (Spannable)text;
         span.setSpan(watcher, 0, text.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
     }

     public void setFilterWatcher(TextWatcher watcher) {
         if (mMode != DIGITS_ONLY) {
             setLettersWatcher(watcher);
         } else {
             setDigitsWatcher(watcher);
         }
     }

     public void removeFilterWatcher(TextWatcher watcher) {
         Spannable text;
         if (mMode != DIGITS_ONLY) {
             text = mLetters.getText();
         } else {
             text = mDigits.getText();
         }
         text.removeSpan(watcher);
     }

     /**
      * Called right after the mode changes to give subclasses the option to
      * restyle, etc.
      */
     protected void onModeChange(int oldMode, int newMode) {
     }

     /** This mode has both lines */
     public static final int DIGITS_AND_LETTERS = 1;
     /** This mode is when after starting in {@link #DIGITS_AND_LETTERS} mode the filter
      *  has removed all possibility of the digits matching, leaving only the letters line */
     public static final int DIGITS_AND_LETTERS_NO_DIGITS = 2;
     /** This mode is when after starting in {@link #DIGITS_AND_LETTERS} mode the filter
      *  has removed all possibility of the letters matching, leaving only the digits line */
     public static final int DIGITS_AND_LETTERS_NO_LETTERS = 3;
     /** This mode has only the digits line */
     public static final int DIGITS_ONLY = 4;
     /** This mode has only the letters line */
     public static final int LETTERS_ONLY = 5;

     EditText mLetters;
     EditText mDigits;
     EditText mPrimary;
     EditText mHint;
     InputFilter mInputFilters[];
     ImageView mIcon;
     int mMode;
     private boolean mIsQwerty;
 }
	/*
	* Copyright (C) 2006 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.widget;

	import android.content.Context;
	import android.view.KeyEvent;
	import android.text.Editable;
	import android.text.InputFilter;
	import android.text.Selection;
	import android.text.Spannable;
	import android.text.Spanned;
	import android.text.TextWatcher;
	import android.text.method.DialerKeyListener;
	import android.text.method.KeyListener;
	import android.text.method.TextKeyListener;
	import android.util.AttributeSet;
	import android.view.View;
	import android.graphics.Rect;



	public class DialerFilter extends RelativeLayout
	{
	public DialerFilter(Context context) {
	super(context);
	}

	public DialerFilter(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

	@Override
	protected void onFinishInflate() {
	super.onFinishInflate();

	// Setup the filter view
	mInputFilters = new InputFilter[] { new InputFilter.AllCaps() };

	mHint = (EditText) findViewById(com.android.internal.R.id.hint);
	if (mHint == null) {
	throw new IllegalStateException("DialerFilter must have a child EditText named hint");
	}
	mHint.setFilters(mInputFilters);

	mLetters = mHint;
	mLetters.setKeyListener(TextKeyListener.getInstance());
	mLetters.setMovementMethod(null);
	mLetters.setFocusable(false);

	// Setup the digits view
	mPrimary = (EditText) findViewById(com.android.internal.R.id.primary);
	if (mPrimary == null) {
	throw new IllegalStateException("DialerFilter must have a child EditText named primary");
	}
	mPrimary.setFilters(mInputFilters);

	mDigits = mPrimary;
	mDigits.setKeyListener(DialerKeyListener.getInstance());
	mDigits.setMovementMethod(null);
	mDigits.setFocusable(false);

	// Look for an icon
	mIcon = (ImageView) findViewById(com.android.internal.R.id.icon);

	// Setup focus & highlight for this view
	setFocusable(true);

	// XXX Force the mode to QWERTY for now, since 12-key isn't supported
	mIsQwerty = true;
	setMode(DIGITS_AND_LETTERS);
	}

	/**
	* Only show the icon view when focused, if there is one.
	*/
	@Override
	protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
	super.onFocusChanged(focused, direction, previouslyFocusedRect);

	if (mIcon != null) {
	mIcon.setVisibility(focused ? View.VISIBLE : View.GONE);
	}
	}


	public boolean isQwertyKeyboard() {
	return mIsQwerty;
	}

	@Override
	public boolean onKeyDown(int keyCode, KeyEvent event) {
	boolean handled = false;

	switch (keyCode) {
	case KeyEvent.KEYCODE_DPAD_UP:
	case KeyEvent.KEYCODE_DPAD_DOWN:
	case KeyEvent.KEYCODE_DPAD_LEFT:
	case KeyEvent.KEYCODE_DPAD_RIGHT:
	case KeyEvent.KEYCODE_ENTER:
	case KeyEvent.KEYCODE_DPAD_CENTER:
	break;

	case KeyEvent.KEYCODE_DEL:
	switch (mMode) {
	case DIGITS_AND_LETTERS:
	handled = mDigits.onKeyDown(keyCode, event);
	handled &= mLetters.onKeyDown(keyCode, event);
	break;

	case DIGITS_AND_LETTERS_NO_DIGITS:
	handled = mLetters.onKeyDown(keyCode, event);
	if (mLetters.getText().length() == mDigits.getText().length()) {
	setMode(DIGITS_AND_LETTERS);
	}
	break;

	case DIGITS_AND_LETTERS_NO_LETTERS:
	if (mDigits.getText().length() == mLetters.getText().length()) {
	mLetters.onKeyDown(keyCode, event);
	setMode(DIGITS_AND_LETTERS);
	}
	handled = mDigits.onKeyDown(keyCode, event);
	break;

	case DIGITS_ONLY:
	handled = mDigits.onKeyDown(keyCode, event);
	break;

	case LETTERS_ONLY:
	handled = mLetters.onKeyDown(keyCode, event);
	break;
	}
	break;

	default:
	//mIsQwerty = msg.getKeyIsQwertyKeyboard();

	switch (mMode) {
	case DIGITS_AND_LETTERS:
	handled = mLetters.onKeyDown(keyCode, event);

	// pass this throw so the shift state is correct (for example,
	// on a standard QWERTY keyboard, * and 8 are on the same key)
	if (KeyEvent.isModifierKey(keyCode)) {
	mDigits.onKeyDown(keyCode, event);
	handled = true;
	break;
	}

	// Only check to see if the digit is valid if the key is a printing key
	// in the TextKeyListener. This prevents us from hiding the digits
	// line when keys like UP and DOWN are hit.
	// XXX note that KEYCODE_TAB is special-cased here for
	// devices that share tab and 0 on a single key.
	boolean isPrint = event.isPrintingKey();
	if (isPrint \|\| keyCode == KeyEvent.KEYCODE_SPACE
	\|\| keyCode == KeyEvent.KEYCODE_TAB) {
	char c = event.getMatch(DialerKeyListener.CHARACTERS);
	if (c != 0) {
	handled &= mDigits.onKeyDown(keyCode, event);
	} else {
	setMode(DIGITS_AND_LETTERS_NO_DIGITS);
	}
	}
	break;

	case DIGITS_AND_LETTERS_NO_LETTERS:
	case DIGITS_ONLY:
	handled = mDigits.onKeyDown(keyCode, event);
	break;

	case DIGITS_AND_LETTERS_NO_DIGITS:
	case LETTERS_ONLY:
	handled = mLetters.onKeyDown(keyCode, event);
	break;
	}
	}

	if (!handled) {
	return super.onKeyDown(keyCode, event);
	} else {
	return true;
	}
	}

	@Override
	public boolean onKeyUp(int keyCode, KeyEvent event) {
	boolean a = mLetters.onKeyUp(keyCode, event);
	boolean b = mDigits.onKeyUp(keyCode, event);
	return a \|\| b;
	}

	public int getMode() {
	return mMode;
	}

	/**
	* Change the mode of the widget.
	*
	* @param newMode The mode to switch to.
	*/
	public void setMode(int newMode) {
	switch (newMode) {
	case DIGITS_AND_LETTERS:
	makeDigitsPrimary();
	mLetters.setVisibility(View.VISIBLE);
	mDigits.setVisibility(View.VISIBLE);
	break;

	case DIGITS_ONLY:
	makeDigitsPrimary();
	mLetters.setVisibility(View.GONE);
	mDigits.setVisibility(View.VISIBLE);
	break;

	case LETTERS_ONLY:
	makeLettersPrimary();
	mLetters.setVisibility(View.VISIBLE);
	mDigits.setVisibility(View.GONE);
	break;

	case DIGITS_AND_LETTERS_NO_LETTERS:
	makeDigitsPrimary();
	mLetters.setVisibility(View.INVISIBLE);
	mDigits.setVisibility(View.VISIBLE);
	break;

	case DIGITS_AND_LETTERS_NO_DIGITS:
	makeLettersPrimary();
	mLetters.setVisibility(View.VISIBLE);
	mDigits.setVisibility(View.INVISIBLE);
	break;

	}
	int oldMode = mMode;
	mMode = newMode;
	onModeChange(oldMode, newMode);
	}

	private void makeLettersPrimary() {
	if (mPrimary == mDigits) {
	swapPrimaryAndHint(true);
	}
	}

	private void makeDigitsPrimary() {
	if (mPrimary == mLetters) {
	swapPrimaryAndHint(false);
	}
	}

	private void swapPrimaryAndHint(boolean makeLettersPrimary) {
	Editable lettersText = mLetters.getText();
	Editable digitsText = mDigits.getText();
	KeyListener lettersInput = mLetters.getKeyListener();
	KeyListener digitsInput = mDigits.getKeyListener();

	if (makeLettersPrimary) {
	mLetters = mPrimary;
	mDigits = mHint;
	} else {
	mLetters = mHint;
	mDigits = mPrimary;
	}

	mLetters.setKeyListener(lettersInput);
	mLetters.setText(lettersText);
	lettersText = mLetters.getText();
	Selection.setSelection(lettersText, lettersText.length());

	mDigits.setKeyListener(digitsInput);
	mDigits.setText(digitsText);
	digitsText = mDigits.getText();
	Selection.setSelection(digitsText, digitsText.length());

	// Reset the filters
	mPrimary.setFilters(mInputFilters);
	mHint.setFilters(mInputFilters);
	}


	public CharSequence getLetters() {
	if (mLetters.getVisibility() == View.VISIBLE) {
	return mLetters.getText();
	} else {
	return "";
	}
	}

	public CharSequence getDigits() {
	if (mDigits.getVisibility() == View.VISIBLE) {
	return mDigits.getText();
	} else {
	return "";
	}
	}

	public CharSequence getFilterText() {
	if (mMode != DIGITS_ONLY) {
	return getLetters();
	} else {
	return getDigits();
	}
	}

	public void append(String text) {
	switch (mMode) {
	case DIGITS_AND_LETTERS:
	mDigits.getText().append(text);
	mLetters.getText().append(text);
	break;

	case DIGITS_AND_LETTERS_NO_LETTERS:
	case DIGITS_ONLY:
	mDigits.getText().append(text);
	break;

	case DIGITS_AND_LETTERS_NO_DIGITS:
	case LETTERS_ONLY:
	mLetters.getText().append(text);
	break;
	}
	}

	/**
	* Clears both the digits and the filter text.
	*/
	public void clearText() {
	Editable text;

	text = mLetters.getText();
	text.clear();

	text = mDigits.getText();
	text.clear();

	// Reset the mode based on the hardware type
	if (mIsQwerty) {
	setMode(DIGITS_AND_LETTERS);
	} else {
	setMode(DIGITS_ONLY);
	}
	}

	public void setLettersWatcher(TextWatcher watcher) {
	CharSequence text = mLetters.getText();
	Spannable span = (Spannable)text;
	span.setSpan(watcher, 0, text.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
	}

	public void setDigitsWatcher(TextWatcher watcher) {
	CharSequence text = mDigits.getText();
	Spannable span = (Spannable)text;
	span.setSpan(watcher, 0, text.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
	}

	public void setFilterWatcher(TextWatcher watcher) {
	if (mMode != DIGITS_ONLY) {
	setLettersWatcher(watcher);
	} else {
	setDigitsWatcher(watcher);
	}
	}

	public void removeFilterWatcher(TextWatcher watcher) {
	Spannable text;
	if (mMode != DIGITS_ONLY) {
	text = mLetters.getText();
	} else {
	text = mDigits.getText();
	}
	text.removeSpan(watcher);
	}

	/**
	* Called right after the mode changes to give subclasses the option to
	* restyle, etc.
	*/
	protected void onModeChange(int oldMode, int newMode) {
	}

	/** This mode has both lines */
	public static final int DIGITS_AND_LETTERS = 1;
	/** This mode is when after starting in {@link #DIGITS_AND_LETTERS} mode the filter
	* has removed all possibility of the digits matching, leaving only the letters line */
	public static final int DIGITS_AND_LETTERS_NO_DIGITS = 2;
	/** This mode is when after starting in {@link #DIGITS_AND_LETTERS} mode the filter
	* has removed all possibility of the letters matching, leaving only the digits line */
	public static final int DIGITS_AND_LETTERS_NO_LETTERS = 3;
	/** This mode has only the digits line */
	public static final int DIGITS_ONLY = 4;
	/** This mode has only the letters line */
	public static final int LETTERS_ONLY = 5;

	EditText mLetters;
	EditText mDigits;
	EditText mPrimary;
	EditText mHint;
	InputFilter mInputFilters[];
	ImageView mIcon;
	int mMode;
	private boolean mIsQwerty;
	}