src/com/android/inputmethod/pinyin/SoftKeyboard.java - platform/packages/inputmethods/PinyinIME - Git at Google

 /*
  * Copyright (C) 2009 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 com.android.inputmethod.pinyin;

 import com.android.inputmethod.pinyin.InputModeSwitcher.ToggleStates;

 import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.view.KeyEvent;

 import java.util.ArrayList;
 import java.util.List;

 /**
  * Class used to represent a soft keyboard definition, including the height, the
  * background image, the image for high light, the keys, etc.
  */
 public class SoftKeyboard {
     /** The XML resource id for this soft keyboard. */
     private int mSkbXmlId;

     /** Do we need to cache this soft keyboard? */
     private boolean mCacheFlag;

     /**
      * After user switches to this soft keyboard, if this flag is true, this
      * soft keyboard will be kept unless explicit switching operation is
      * performed, otherwise IME will switch back to the previous keyboard layout
      * whenever user clicks on any none-function key.
      **/
     private boolean mStickyFlag;

     /**
      * The cache id for this soft keyboard. It is used to identify it in the
      * soft keyboard pool.
      */
     private int mCacheId;

     /**
      * Used to indicate whether this soft keyboard is newly loaded from an XML
      * file or is just gotten from the soft keyboard pool.
      */
     private boolean mNewlyLoadedFlag = true;

     /** The width of the soft keyboard. */
     private int mSkbCoreWidth;

     /** The height of the soft keyboard. */
     private int mSkbCoreHeight;

     /** The soft keyboard template for this soft keyboard. */
     private SkbTemplate mSkbTemplate;

     /** Used to indicate whether this soft keyboard is a QWERTY keyboard. */
     private boolean mIsQwerty;

     /**
      * When {@link #mIsQwerty} is true, this member is Used to indicate that the
      * soft keyboard should be displayed in uppercase.
      */
     private boolean mIsQwertyUpperCase;

     /**
      * The id of the rows which are enabled. Rows with id
      * {@link KeyRow#ALWAYS_SHOW_ROW_ID} are always enabled.
      */
     private int mEnabledRowId;

     /**
      * Rows in this soft keyboard. Each row has a id. Only matched rows will be
      * enabled.
      */
     private List<KeyRow> mKeyRows;

     /**
      * Background of the soft keyboard. If it is null, the one in the soft
      * keyboard template will be used.
      **/
     public Drawable mSkbBg;

     /**
      * Background for key balloon. If it is null, the one in the soft keyboard
      * template will be used.
      **/
     private Drawable mBalloonBg;

     /**
      * Background for popup mini soft keyboard. If it is null, the one in the
      * soft keyboard template will be used.
      **/
     private Drawable mPopupBg;

     /** The left and right margin of a key. */
     private float mKeyXMargin = 0;

     /** The top and bottom margin of a key. */
     private float mKeyYMargin = 0;

     private Rect mTmpRect = new Rect();

     public SoftKeyboard(int skbXmlId, SkbTemplate skbTemplate, int skbWidth,
             int skbHeight) {
         mSkbXmlId = skbXmlId;
         mSkbTemplate = skbTemplate;
         mSkbCoreWidth = skbWidth;
         mSkbCoreHeight = skbHeight;
     }

     public void setFlags(boolean cacheFlag, boolean stickyFlag,
             boolean isQwerty, boolean isQwertyUpperCase) {
         mCacheFlag = cacheFlag;
         mStickyFlag = stickyFlag;
         mIsQwerty = isQwerty;
         mIsQwertyUpperCase = isQwertyUpperCase;
     }

     public boolean getCacheFlag() {
         return mCacheFlag;
     }

     public void setCacheId(int cacheId) {
         mCacheId = cacheId;
     }

     public boolean getStickyFlag() {
         return mStickyFlag;
     }

     public void setSkbBackground(Drawable skbBg) {
         mSkbBg = skbBg;
     }

     public void setPopupBackground(Drawable popupBg) {
         mPopupBg = popupBg;
     }

     public void setKeyBalloonBackground(Drawable balloonBg) {
         mBalloonBg = balloonBg;
     }

     public void setKeyMargins(float xMargin, float yMargin) {
         mKeyXMargin = xMargin;
         mKeyYMargin = yMargin;
     }

     public int getCacheId() {
         return mCacheId;
     }

     public void reset() {
         if (null != mKeyRows) mKeyRows.clear();
     }

     public void setNewlyLoadedFlag(boolean newlyLoadedFlag) {
         mNewlyLoadedFlag = newlyLoadedFlag;
     }

     public boolean getNewlyLoadedFlag() {
         return mNewlyLoadedFlag;
     }

     public void beginNewRow(int rowId, float yStartingPos) {
         if (null == mKeyRows) mKeyRows = new ArrayList<KeyRow>();
         KeyRow keyRow = new KeyRow();
         keyRow.mRowId = rowId;
         keyRow.mTopF = yStartingPos;
         keyRow.mBottomF = yStartingPos;
         keyRow.mSoftKeys = new ArrayList<SoftKey>();
         mKeyRows.add(keyRow);
     }

     public boolean addSoftKey(SoftKey softKey) {
         if (mKeyRows.size() == 0) return false;
         KeyRow keyRow = mKeyRows.get(mKeyRows.size() - 1);
         if (null == keyRow) return false;
         List<SoftKey> softKeys = keyRow.mSoftKeys;

         softKey.setSkbCoreSize(mSkbCoreWidth, mSkbCoreHeight);
         softKeys.add(softKey);
         if (softKey.mTopF < keyRow.mTopF) {
             keyRow.mTopF = softKey.mTopF;
         }
         if (softKey.mBottomF > keyRow.mBottomF) {
             keyRow.mBottomF = softKey.mBottomF;
         }
         return true;
     }

     public int getSkbXmlId() {
         return mSkbXmlId;
     }

     // Set the size of the soft keyboard core. In other words, the background's
     // padding are not counted.
     public void setSkbCoreSize(int skbCoreWidth, int skbCoreHeight) {
         if (null == mKeyRows
                 || (skbCoreWidth == mSkbCoreWidth && skbCoreHeight == mSkbCoreHeight)) {
             return;
         }
         for (int row = 0; row < mKeyRows.size(); row++) {
             KeyRow keyRow = mKeyRows.get(row);
             keyRow.mBottom = (int) (skbCoreHeight * keyRow.mBottomF);
             keyRow.mTop = (int) (skbCoreHeight * keyRow.mTopF);

             List<SoftKey> softKeys = keyRow.mSoftKeys;
             for (int i = 0; i < softKeys.size(); i++) {
                 SoftKey softKey = softKeys.get(i);
                 softKey.setSkbCoreSize(skbCoreWidth, skbCoreHeight);
             }
         }
         mSkbCoreWidth = skbCoreWidth;
         mSkbCoreHeight = skbCoreHeight;
     }

     public int getSkbCoreWidth() {
         return mSkbCoreWidth;
     }

     public int getSkbCoreHeight() {
         return mSkbCoreHeight;
     }

     public int getSkbTotalWidth() {
         Rect padding = getPadding();
         return mSkbCoreWidth + padding.left + padding.right;
     }

     public int getSkbTotalHeight() {
         Rect padding = getPadding();
         return mSkbCoreHeight + padding.top + padding.bottom;
     }

     public int getKeyXMargin() {
         Environment env = Environment.getInstance();
         return (int) (mKeyXMargin * mSkbCoreWidth * env.getKeyXMarginFactor());
     }

     public int getKeyYMargin() {
         Environment env = Environment.getInstance();
         return (int) (mKeyYMargin * mSkbCoreHeight * env.getKeyYMarginFactor());
     }

     public Drawable getSkbBackground() {
         if (null != mSkbBg) return mSkbBg;
         return mSkbTemplate.getSkbBackground();
     }

     public Drawable getBalloonBackground() {
         if (null != mBalloonBg) return mBalloonBg;
         return mSkbTemplate.getBalloonBackground();
     }

     public Drawable getPopupBackground() {
         if (null != mPopupBg) return mPopupBg;
         return mSkbTemplate.getPopupBackground();
     }

     public int getRowNum() {
         if (null != mKeyRows) {
             return mKeyRows.size();
         }
         return 0;
     }

     public KeyRow getKeyRowForDisplay(int row) {
         if (null != mKeyRows && mKeyRows.size() > row) {
             KeyRow keyRow = mKeyRows.get(row);
             if (KeyRow.ALWAYS_SHOW_ROW_ID == keyRow.mRowId
                     || keyRow.mRowId == mEnabledRowId) {
                 return keyRow;
             }
         }
         return null;
     }

     public SoftKey getKey(int row, int location) {
         if (null != mKeyRows && mKeyRows.size() > row) {
             List<SoftKey> softKeys = mKeyRows.get(row).mSoftKeys;
             if (softKeys.size() > location) {
                 return softKeys.get(location);
             }
         }
         return null;
     }

     public SoftKey mapToKey(int x, int y) {
         if (null == mKeyRows) {
             return null;
         }
         // If the position is inside the rectangle of a certain key, return that
         // key.
         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
                     && keyRow.mRowId != mEnabledRowId) continue;
             if (keyRow.mTop > y && keyRow.mBottom <= y) continue;

             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < keyNum; i++) {
                 SoftKey sKey = softKeys.get(i);
                 if (sKey.mLeft <= x && sKey.mTop <= y && sKey.mRight > x
                         && sKey.mBottom > y) {
                     return sKey;
                 }
             }
         }

         // If the position is outside the rectangles of all keys, find the
         // nearest one.
         SoftKey nearestKey = null;
         float nearestDis = Float.MAX_VALUE;
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
                     && keyRow.mRowId != mEnabledRowId) continue;
             if (keyRow.mTop > y && keyRow.mBottom <= y) continue;

             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < keyNum; i++) {
                 SoftKey sKey = softKeys.get(i);
                 int disx = (sKey.mLeft + sKey.mRight) / 2 - x;
                 int disy = (sKey.mTop + sKey.mBottom) / 2 - y;
                 float dis = disx * disx + disy * disy;
                 if (dis < nearestDis) {
                     nearestDis = dis;
                     nearestKey = sKey;
                 }
             }
         }
         return nearestKey;
     }

     public void switchQwertyMode(int toggle_state_id, boolean upperCase) {
         if (!mIsQwerty) return;

         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < keyNum; i++) {
                 SoftKey sKey = softKeys.get(i);
                 if (sKey instanceof SoftKeyToggle) {
                     ((SoftKeyToggle) sKey).enableToggleState(toggle_state_id,
                             true);
                 }
                 if (sKey.mKeyCode >= KeyEvent.KEYCODE_A
                         && sKey.mKeyCode <= KeyEvent.KEYCODE_Z) {
                     sKey.changeCase(upperCase);
                 }
             }
         }
     }

     public void enableToggleState(int toggleStateId, boolean resetIfNotFound) {
         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < keyNum; i++) {
                 SoftKey sKey = softKeys.get(i);
                 if (sKey instanceof SoftKeyToggle) {
                     ((SoftKeyToggle) sKey).enableToggleState(toggleStateId,
                             resetIfNotFound);
                 }
             }
         }
     }

     public void disableToggleState(int toggleStateId, boolean resetIfNotFound) {
         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < keyNum; i++) {
                 SoftKey sKey = softKeys.get(i);
                 if (sKey instanceof SoftKeyToggle) {
                     ((SoftKeyToggle) sKey).disableToggleState(toggleStateId,
                             resetIfNotFound);
                 }
             }
         }
     }

     public void enableToggleStates(ToggleStates toggleStates) {
         if (null == toggleStates) return;

         enableRow(toggleStates.mRowIdToEnable);

         boolean isQwerty = toggleStates.mQwerty;
         boolean isQwertyUpperCase = toggleStates.mQwertyUpperCase;
         boolean needUpdateQwerty = (isQwerty && mIsQwerty && (mIsQwertyUpperCase != isQwertyUpperCase));
         int states[] = toggleStates.mKeyStates;
         int statesNum = toggleStates.mKeyStatesNum;

         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
                     && keyRow.mRowId != mEnabledRowId) {
                 continue;
             }
             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int keyPos = 0; keyPos < keyNum; keyPos++) {
                 SoftKey sKey = softKeys.get(keyPos);
                 if (sKey instanceof SoftKeyToggle) {
                     for (int statePos = 0; statePos < statesNum; statePos++) {
                         ((SoftKeyToggle) sKey).enableToggleState(
                                 states[statePos], statePos == 0);
                     }
                     if (0 == statesNum) {
                         ((SoftKeyToggle) sKey).disableAllToggleStates();
                     }
                 }
                 if (needUpdateQwerty) {
                     if (sKey.mKeyCode >= KeyEvent.KEYCODE_A
                             && sKey.mKeyCode <= KeyEvent.KEYCODE_Z) {
                         sKey.changeCase(isQwertyUpperCase);
                     }
                 }
             }
         }
         mIsQwertyUpperCase = isQwertyUpperCase;
     }

     private Rect getPadding() {
         mTmpRect.set(0, 0, 0, 0);
         Drawable skbBg = getSkbBackground();
         if (null == skbBg) return mTmpRect;
         skbBg.getPadding(mTmpRect);
         return mTmpRect;
     }

     /**
      * Enable a row with the give toggle Id. Rows with other toggle ids (except
      * the id {@link KeyRow#ALWAYS_SHOW_ROW_ID}) will be disabled.
      *
      * @param rowId The row id to enable.
      * @return True if the soft keyboard requires redrawing.
      */
     private boolean enableRow(int rowId) {
         if (KeyRow.ALWAYS_SHOW_ROW_ID == rowId) return false;

         boolean enabled = false;
         int rowNum = mKeyRows.size();
         for (int row = rowNum - 1; row >= 0; row--) {
             if (mKeyRows.get(row).mRowId == rowId) {
                 enabled = true;
                 break;
             }
         }
         if (enabled) {
             mEnabledRowId = rowId;
         }
         return enabled;
     }

     @Override
     public String toString() {
         String str = "------------------SkbInfo----------------------\n";
         String endStr = "-----------------------------------------------\n";
         str += "Width: " + String.valueOf(mSkbCoreWidth) + "\n";
         str += "Height: " + String.valueOf(mSkbCoreHeight) + "\n";
         str += "KeyRowNum: " + mKeyRows == null ? "0" : String.valueOf(mKeyRows
                 .size())
                 + "\n";
         if (null == mKeyRows) return str + endStr;
         int rowNum = mKeyRows.size();
         for (int row = 0; row < rowNum; row++) {
             KeyRow keyRow = mKeyRows.get(row);
             List<SoftKey> softKeys = keyRow.mSoftKeys;
             int keyNum = softKeys.size();
             for (int i = 0; i < softKeys.size(); i++) {
                 str += "-key " + String.valueOf(i) + ":"
                         + softKeys.get(i).toString();
             }
         }
         return str + endStr;
     }

     public String toShortString() {
         return super.toString();
     }

     class KeyRow {
         static final int ALWAYS_SHOW_ROW_ID = -1;
         static final int DEFAULT_ROW_ID = 0;

         List<SoftKey> mSoftKeys;
         /**
          * If the row id is {@link #ALWAYS_SHOW_ROW_ID}, this row will always be
          * enabled.
          */
         int mRowId;
         float mTopF;
         float mBottomF;
         int mTop;
         int mBottom;
     }
 }
	/*
	* Copyright (C) 2009 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 com.android.inputmethod.pinyin;

	import com.android.inputmethod.pinyin.InputModeSwitcher.ToggleStates;

	import android.graphics.Rect;
	import android.graphics.drawable.Drawable;
	import android.view.KeyEvent;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* Class used to represent a soft keyboard definition, including the height, the
	* background image, the image for high light, the keys, etc.
	*/
	public class SoftKeyboard {
	/** The XML resource id for this soft keyboard. */
	private int mSkbXmlId;

	/** Do we need to cache this soft keyboard? */
	private boolean mCacheFlag;

	/**
	* After user switches to this soft keyboard, if this flag is true, this
	* soft keyboard will be kept unless explicit switching operation is
	* performed, otherwise IME will switch back to the previous keyboard layout
	* whenever user clicks on any none-function key.
	**/
	private boolean mStickyFlag;

	/**
	* The cache id for this soft keyboard. It is used to identify it in the
	* soft keyboard pool.
	*/
	private int mCacheId;

	/**
	* Used to indicate whether this soft keyboard is newly loaded from an XML
	* file or is just gotten from the soft keyboard pool.
	*/
	private boolean mNewlyLoadedFlag = true;

	/** The width of the soft keyboard. */
	private int mSkbCoreWidth;

	/** The height of the soft keyboard. */
	private int mSkbCoreHeight;

	/** The soft keyboard template for this soft keyboard. */
	private SkbTemplate mSkbTemplate;

	/** Used to indicate whether this soft keyboard is a QWERTY keyboard. */
	private boolean mIsQwerty;

	/**
	* When {@link #mIsQwerty} is true, this member is Used to indicate that the
	* soft keyboard should be displayed in uppercase.
	*/
	private boolean mIsQwertyUpperCase;

	/**
	* The id of the rows which are enabled. Rows with id
	* {@link KeyRow#ALWAYS_SHOW_ROW_ID} are always enabled.
	*/
	private int mEnabledRowId;

	/**
	* Rows in this soft keyboard. Each row has a id. Only matched rows will be
	* enabled.
	*/
	private List<KeyRow> mKeyRows;

	/**
	* Background of the soft keyboard. If it is null, the one in the soft
	* keyboard template will be used.
	**/
	public Drawable mSkbBg;

	/**
	* Background for key balloon. If it is null, the one in the soft keyboard
	* template will be used.
	**/
	private Drawable mBalloonBg;

	/**
	* Background for popup mini soft keyboard. If it is null, the one in the
	* soft keyboard template will be used.
	**/
	private Drawable mPopupBg;

	/** The left and right margin of a key. */
	private float mKeyXMargin = 0;

	/** The top and bottom margin of a key. */
	private float mKeyYMargin = 0;

	private Rect mTmpRect = new Rect();

	public SoftKeyboard(int skbXmlId, SkbTemplate skbTemplate, int skbWidth,
	int skbHeight) {
	mSkbXmlId = skbXmlId;
	mSkbTemplate = skbTemplate;
	mSkbCoreWidth = skbWidth;
	mSkbCoreHeight = skbHeight;
	}

	public void setFlags(boolean cacheFlag, boolean stickyFlag,
	boolean isQwerty, boolean isQwertyUpperCase) {
	mCacheFlag = cacheFlag;
	mStickyFlag = stickyFlag;
	mIsQwerty = isQwerty;
	mIsQwertyUpperCase = isQwertyUpperCase;
	}

	public boolean getCacheFlag() {
	return mCacheFlag;
	}

	public void setCacheId(int cacheId) {
	mCacheId = cacheId;
	}

	public boolean getStickyFlag() {
	return mStickyFlag;
	}

	public void setSkbBackground(Drawable skbBg) {
	mSkbBg = skbBg;
	}

	public void setPopupBackground(Drawable popupBg) {
	mPopupBg = popupBg;
	}

	public void setKeyBalloonBackground(Drawable balloonBg) {
	mBalloonBg = balloonBg;
	}

	public void setKeyMargins(float xMargin, float yMargin) {
	mKeyXMargin = xMargin;
	mKeyYMargin = yMargin;
	}

	public int getCacheId() {
	return mCacheId;
	}

	public void reset() {
	if (null != mKeyRows) mKeyRows.clear();
	}

	public void setNewlyLoadedFlag(boolean newlyLoadedFlag) {
	mNewlyLoadedFlag = newlyLoadedFlag;
	}

	public boolean getNewlyLoadedFlag() {
	return mNewlyLoadedFlag;
	}

	public void beginNewRow(int rowId, float yStartingPos) {
	if (null == mKeyRows) mKeyRows = new ArrayList<KeyRow>();
	KeyRow keyRow = new KeyRow();
	keyRow.mRowId = rowId;
	keyRow.mTopF = yStartingPos;
	keyRow.mBottomF = yStartingPos;
	keyRow.mSoftKeys = new ArrayList<SoftKey>();
	mKeyRows.add(keyRow);
	}

	public boolean addSoftKey(SoftKey softKey) {
	if (mKeyRows.size() == 0) return false;
	KeyRow keyRow = mKeyRows.get(mKeyRows.size() - 1);
	if (null == keyRow) return false;
	List<SoftKey> softKeys = keyRow.mSoftKeys;

	softKey.setSkbCoreSize(mSkbCoreWidth, mSkbCoreHeight);
	softKeys.add(softKey);
	if (softKey.mTopF < keyRow.mTopF) {
	keyRow.mTopF = softKey.mTopF;
	}
	if (softKey.mBottomF > keyRow.mBottomF) {
	keyRow.mBottomF = softKey.mBottomF;
	}
	return true;
	}

	public int getSkbXmlId() {
	return mSkbXmlId;
	}

	// Set the size of the soft keyboard core. In other words, the background's
	// padding are not counted.
	public void setSkbCoreSize(int skbCoreWidth, int skbCoreHeight) {
	if (null == mKeyRows
	\|\| (skbCoreWidth == mSkbCoreWidth && skbCoreHeight == mSkbCoreHeight)) {
	return;
	}
	for (int row = 0; row < mKeyRows.size(); row++) {
	KeyRow keyRow = mKeyRows.get(row);
	keyRow.mBottom = (int) (skbCoreHeight * keyRow.mBottomF);
	keyRow.mTop = (int) (skbCoreHeight * keyRow.mTopF);

	List<SoftKey> softKeys = keyRow.mSoftKeys;
	for (int i = 0; i < softKeys.size(); i++) {
	SoftKey softKey = softKeys.get(i);
	softKey.setSkbCoreSize(skbCoreWidth, skbCoreHeight);
	}
	}
	mSkbCoreWidth = skbCoreWidth;
	mSkbCoreHeight = skbCoreHeight;
	}

	public int getSkbCoreWidth() {
	return mSkbCoreWidth;
	}

	public int getSkbCoreHeight() {
	return mSkbCoreHeight;
	}

	public int getSkbTotalWidth() {
	Rect padding = getPadding();
	return mSkbCoreWidth + padding.left + padding.right;
	}

	public int getSkbTotalHeight() {
	Rect padding = getPadding();
	return mSkbCoreHeight + padding.top + padding.bottom;
	}

	public int getKeyXMargin() {
	Environment env = Environment.getInstance();
	return (int) (mKeyXMargin * mSkbCoreWidth * env.getKeyXMarginFactor());
	}

	public int getKeyYMargin() {
	Environment env = Environment.getInstance();
	return (int) (mKeyYMargin * mSkbCoreHeight * env.getKeyYMarginFactor());
	}

	public Drawable getSkbBackground() {
	if (null != mSkbBg) return mSkbBg;
	return mSkbTemplate.getSkbBackground();
	}

	public Drawable getBalloonBackground() {
	if (null != mBalloonBg) return mBalloonBg;
	return mSkbTemplate.getBalloonBackground();
	}

	public Drawable getPopupBackground() {
	if (null != mPopupBg) return mPopupBg;
	return mSkbTemplate.getPopupBackground();
	}

	public int getRowNum() {
	if (null != mKeyRows) {
	return mKeyRows.size();
	}
	return 0;
	}

	public KeyRow getKeyRowForDisplay(int row) {
	if (null != mKeyRows && mKeyRows.size() > row) {
	KeyRow keyRow = mKeyRows.get(row);
	if (KeyRow.ALWAYS_SHOW_ROW_ID == keyRow.mRowId
	\|\| keyRow.mRowId == mEnabledRowId) {
	return keyRow;
	}
	}
	return null;
	}

	public SoftKey getKey(int row, int location) {
	if (null != mKeyRows && mKeyRows.size() > row) {
	List<SoftKey> softKeys = mKeyRows.get(row).mSoftKeys;
	if (softKeys.size() > location) {
	return softKeys.get(location);
	}
	}
	return null;
	}

	public SoftKey mapToKey(int x, int y) {
	if (null == mKeyRows) {
	return null;
	}
	// If the position is inside the rectangle of a certain key, return that
	// key.
	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
	&& keyRow.mRowId != mEnabledRowId) continue;
	if (keyRow.mTop > y && keyRow.mBottom <= y) continue;

	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < keyNum; i++) {
	SoftKey sKey = softKeys.get(i);
	if (sKey.mLeft <= x && sKey.mTop <= y && sKey.mRight > x
	&& sKey.mBottom > y) {
	return sKey;
	}
	}
	}

	// If the position is outside the rectangles of all keys, find the
	// nearest one.
	SoftKey nearestKey = null;
	float nearestDis = Float.MAX_VALUE;
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
	&& keyRow.mRowId != mEnabledRowId) continue;
	if (keyRow.mTop > y && keyRow.mBottom <= y) continue;

	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < keyNum; i++) {
	SoftKey sKey = softKeys.get(i);
	int disx = (sKey.mLeft + sKey.mRight) / 2 - x;
	int disy = (sKey.mTop + sKey.mBottom) / 2 - y;
	float dis = disx * disx + disy * disy;
	if (dis < nearestDis) {
	nearestDis = dis;
	nearestKey = sKey;
	}
	}
	}
	return nearestKey;
	}

	public void switchQwertyMode(int toggle_state_id, boolean upperCase) {
	if (!mIsQwerty) return;

	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < keyNum; i++) {
	SoftKey sKey = softKeys.get(i);
	if (sKey instanceof SoftKeyToggle) {
	((SoftKeyToggle) sKey).enableToggleState(toggle_state_id,
	true);
	}
	if (sKey.mKeyCode >= KeyEvent.KEYCODE_A
	&& sKey.mKeyCode <= KeyEvent.KEYCODE_Z) {
	sKey.changeCase(upperCase);
	}
	}
	}
	}

	public void enableToggleState(int toggleStateId, boolean resetIfNotFound) {
	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < keyNum; i++) {
	SoftKey sKey = softKeys.get(i);
	if (sKey instanceof SoftKeyToggle) {
	((SoftKeyToggle) sKey).enableToggleState(toggleStateId,
	resetIfNotFound);
	}
	}
	}
	}

	public void disableToggleState(int toggleStateId, boolean resetIfNotFound) {
	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < keyNum; i++) {
	SoftKey sKey = softKeys.get(i);
	if (sKey instanceof SoftKeyToggle) {
	((SoftKeyToggle) sKey).disableToggleState(toggleStateId,
	resetIfNotFound);
	}
	}
	}
	}

	public void enableToggleStates(ToggleStates toggleStates) {
	if (null == toggleStates) return;

	enableRow(toggleStates.mRowIdToEnable);

	boolean isQwerty = toggleStates.mQwerty;
	boolean isQwertyUpperCase = toggleStates.mQwertyUpperCase;
	boolean needUpdateQwerty = (isQwerty && mIsQwerty && (mIsQwertyUpperCase != isQwertyUpperCase));
	int states[] = toggleStates.mKeyStates;
	int statesNum = toggleStates.mKeyStatesNum;

	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	if (KeyRow.ALWAYS_SHOW_ROW_ID != keyRow.mRowId
	&& keyRow.mRowId != mEnabledRowId) {
	continue;
	}
	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int keyPos = 0; keyPos < keyNum; keyPos++) {
	SoftKey sKey = softKeys.get(keyPos);
	if (sKey instanceof SoftKeyToggle) {
	for (int statePos = 0; statePos < statesNum; statePos++) {
	((SoftKeyToggle) sKey).enableToggleState(
	states[statePos], statePos == 0);
	}
	if (0 == statesNum) {
	((SoftKeyToggle) sKey).disableAllToggleStates();
	}
	}
	if (needUpdateQwerty) {
	if (sKey.mKeyCode >= KeyEvent.KEYCODE_A
	&& sKey.mKeyCode <= KeyEvent.KEYCODE_Z) {
	sKey.changeCase(isQwertyUpperCase);
	}
	}
	}
	}
	mIsQwertyUpperCase = isQwertyUpperCase;
	}

	private Rect getPadding() {
	mTmpRect.set(0, 0, 0, 0);
	Drawable skbBg = getSkbBackground();
	if (null == skbBg) return mTmpRect;
	skbBg.getPadding(mTmpRect);
	return mTmpRect;
	}

	/**
	* Enable a row with the give toggle Id. Rows with other toggle ids (except
	* the id {@link KeyRow#ALWAYS_SHOW_ROW_ID}) will be disabled.
	*
	* @param rowId The row id to enable.
	* @return True if the soft keyboard requires redrawing.
	*/
	private boolean enableRow(int rowId) {
	if (KeyRow.ALWAYS_SHOW_ROW_ID == rowId) return false;

	boolean enabled = false;
	int rowNum = mKeyRows.size();
	for (int row = rowNum - 1; row >= 0; row--) {
	if (mKeyRows.get(row).mRowId == rowId) {
	enabled = true;
	break;
	}
	}
	if (enabled) {
	mEnabledRowId = rowId;
	}
	return enabled;
	}

	@Override
	public String toString() {
	String str = "------------------SkbInfo----------------------\n";
	String endStr = "-----------------------------------------------\n";
	str += "Width: " + String.valueOf(mSkbCoreWidth) + "\n";
	str += "Height: " + String.valueOf(mSkbCoreHeight) + "\n";
	str += "KeyRowNum: " + mKeyRows == null ? "0" : String.valueOf(mKeyRows
	.size())
	+ "\n";
	if (null == mKeyRows) return str + endStr;
	int rowNum = mKeyRows.size();
	for (int row = 0; row < rowNum; row++) {
	KeyRow keyRow = mKeyRows.get(row);
	List<SoftKey> softKeys = keyRow.mSoftKeys;
	int keyNum = softKeys.size();
	for (int i = 0; i < softKeys.size(); i++) {
	str += "-key " + String.valueOf(i) + ":"
	+ softKeys.get(i).toString();
	}
	}
	return str + endStr;
	}

	public String toShortString() {
	return super.toString();
	}

	class KeyRow {
	static final int ALWAYS_SHOW_ROW_ID = -1;
	static final int DEFAULT_ROW_ID = 0;

	List<SoftKey> mSoftKeys;
	/**
	* If the row id is {@link #ALWAYS_SHOW_ROW_ID}, this row will always be
	* enabled.
	*/
	int mRowId;
	float mTopF;
	float mBottomF;
	int mTop;
	int mBottom;
	}
	}