/*
* 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;
}
}
|
