Merge "Calculate x coordinate with floating point"

java/res/xml/kbd_rows_russian.xml

@@ -29,8 +29,7 @@
         <Key
             latin:keyLabel="й"
             latin:keyHintLabel="1"
-            latin:moreKeys="1"
+            latin:moreKeys="1" />
-            latin:keyWidth="8.75%p" />
         <Key
             latin:keyLabel="ц"
             latin:keyHintLabel="2"

java/res/xml/kbd_rows_scandinavian.xml

@@ -24,13 +24,12 @@
     <include
         latin:keyboardLayout="@xml/kbd_key_styles" />
     <Row
-        latin:keyWidth="9.09%p"
+        latin:keyWidth="9.091%p"
     >
         <Key
             latin:keyLabel="q"
             latin:keyHintLabel="1"
-            latin:moreKeys="@string/more_keys_for_q"
+            latin:moreKeys="@string/more_keys_for_q" />
-            latin:keyWidth="8.75%p" />
         <Key
             latin:keyLabel="w"
             latin:keyHintLabel="2"
@@ -72,7 +71,7 @@
             latin:keyWidth="fillRight" />
     </Row>
     <Row
-        latin:keyWidth="9.09%p"
+        latin:keyWidth="9.091%p"
     >
         <Key
             latin:keyLabel="a"

java/res/xml/kbd_rows_serbian.xml

@@ -24,7 +24,7 @@
     <include
         latin:keyboardLayout="@xml/kbd_key_styles" />
     <Row
-        latin:keyWidth="9.09%p"
+        latin:keyWidth="9.091%p"
     >
         <Key
             latin:keyLabel="љ"
@@ -71,7 +71,7 @@
             latin:keyWidth="fillRight" />
     </Row>
     <Row
-        latin:keyWidth="9.09%p"
+        latin:keyWidth="9.091%p"
     >
         <Key
             latin:keyLabel="а" />
@@ -98,10 +98,11 @@
             latin:keyWidth="fillRight" />
     </Row>
     <Row
-        latin:keyWidth="8.90%p"
+        latin:keyWidth="8.5%p"
     >
         <Key
-            latin:keyStyle="shiftKeyStyle" />
+            latin:keyStyle="shiftKeyStyle"
+            latin:keyWidth="11.75%p" />
         <Key
             latin:keyLabel="ѕ" />
         <Key

java/src/com/android/inputmethod/keyboard/Key.java

@@ -253,25 +253,19 @@ public class Key {
 
         final TypedArray keyboardAttr = res.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard);
-        int keyWidth;
+        mHeight = (int)KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
-        try {
+                R.styleable.Keyboard_rowHeight, params.mHeight, row.mRowHeight)
-            mHeight = KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
+                - params.mVerticalGap;
-                    R.styleable.Keyboard_rowHeight,
+        final float horizontalGap = KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
-                    params.mHeight, row.mRowHeight) - params.mVerticalGap;
+                R.styleable.Keyboard_horizontalGap, params.mWidth, params.mHorizontalGap);
-            mHorizontalGap = KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_horizontalGap,
-                    params.mWidth, params.mHorizontalGap);
         mVerticalGap = params.mVerticalGap;
-            keyWidth = KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
+        float keyWidth = KeyboardBuilder.getDimensionOrFraction(keyboardAttr,
-                    R.styleable.Keyboard_keyWidth,
+                R.styleable.Keyboard_keyWidth, params.mWidth, row.mDefaultKeyWidth);
-                    params.mWidth, row.mDefaultKeyWidth);
-        } finally {
         keyboardAttr.recycle();
-        }
 
         final TypedArray keyAttr = res.obtainAttributes(Xml.asAttributeSet(parser),
                 R.styleable.Keyboard_Key);
-        try {
+
         final KeyStyle style;
         if (keyAttr.hasValue(R.styleable.Keyboard_Key_keyStyle)) {
             String styleName = keyAttr.getString(R.styleable.Keyboard_Key_keyStyle);
@@ -283,11 +277,11 @@ public class Key {
         }
 
         final int keyboardWidth = params.mOccupiedWidth;
-            final int x = row.mCurrentX;
+        final float x = row.mCurrentX;
-            int keyXPos = KeyboardBuilder.getDimensionOrFraction(keyAttr,
+        float keyXPos = KeyboardBuilder.getDimensionOrFraction(keyAttr,
                 R.styleable.Keyboard_Key_keyXPos, keyboardWidth, x);
         if (keyXPos < 0) {
-                // If keyXPos is negative, the actual x-coordinate will be k + keyXPos.
+            // If keyXPos is negative, the actual x-coordinate will be keyboardWidth + keyXPos.
             keyXPos += keyboardWidth;
             if (keyXPos < x) {
                 // keyXPos shouldn't be less than x because drawable area for this key starts
@@ -308,26 +302,24 @@ public class Key {
         }
 
         // Horizontal gap is divided equally to both sides of the key.
-            mX = keyXPos + mHorizontalGap / 2;
+        mX = (int) (keyXPos + horizontalGap / 2);
         mY = row.mCurrentY;
-            mWidth = keyWidth - mHorizontalGap;
+        mWidth = (int) (keyWidth - horizontalGap);
-
+        mHorizontalGap = (int) horizontalGap;
-            // Update row to have x-coordinate of the right edge of this key.
+        // Update row to have current x coordinate.
         row.mCurrentX = keyXPos + keyWidth;
 
-            final CharSequence[] moreKeys = style.getTextArray(
+        final CharSequence[] moreKeys = style.getTextArray(keyAttr,
-                    keyAttr, R.styleable.Keyboard_Key_moreKeys);
+                R.styleable.Keyboard_Key_moreKeys);
         // In Arabic symbol layouts, we'd like to keep digits in more keys regardless of
         // config_digit_more_keys_enabled.
-            if (params.mId.isAlphabetKeyboard() && !res.getBoolean(
+        if (params.mId.isAlphabetKeyboard()
-                    R.bool.config_digit_more_keys_enabled)) {
+                && !res.getBoolean(R.bool.config_digit_more_keys_enabled)) {
-                mMoreKeys = MoreKeySpecParser.filterOut(
+            mMoreKeys = MoreKeySpecParser.filterOut(res, moreKeys, MoreKeySpecParser.DIGIT_FILTER);
-                        res, moreKeys, MoreKeySpecParser.DIGIT_FILTER);
         } else {
             mMoreKeys = moreKeys;
         }
-            mMaxMoreKeysColumn = style.getInt(keyboardAttr,
+        mMaxMoreKeysColumn = style.getInt(keyboardAttr, R.styleable.Keyboard_Key_maxMoreKeysColumn,
-                    R.styleable.Keyboard_Key_maxMoreKeysColumn,
                 params.mMaxMiniKeyboardColumn);
 
         mRepeatable = style.getBoolean(keyAttr, R.styleable.Keyboard_Key_isRepeatable, false);
@@ -337,15 +329,13 @@ public class Key {
         mEdgeFlags = 0;
 
         final KeyboardIconsSet iconsSet = params.mIconsSet;
-            mVisualInsetsLeft = KeyboardBuilder.getDimensionOrFraction(keyAttr,
+        mVisualInsetsLeft = (int) KeyboardBuilder.getDimensionOrFraction(keyAttr,
                 R.styleable.Keyboard_Key_visualInsetsLeft, keyboardWidth, 0);
-            mVisualInsetsRight = KeyboardBuilder.getDimensionOrFraction(keyAttr,
+        mVisualInsetsRight = (int) KeyboardBuilder.getDimensionOrFraction(keyAttr,
                 R.styleable.Keyboard_Key_visualInsetsRight, keyboardWidth, 0);
-            mPreviewIcon = iconsSet.getIcon(style.getInt(
+        mPreviewIcon = iconsSet.getIcon(style.getInt(keyAttr,
-                    keyAttr, R.styleable.Keyboard_Key_keyIconPreview,
+                R.styleable.Keyboard_Key_keyIconPreview, KeyboardIconsSet.ICON_UNDEFINED));
-                    KeyboardIconsSet.ICON_UNDEFINED));
+        mIcon = iconsSet.getIcon(style.getInt(keyAttr, R.styleable.Keyboard_Key_keyIcon,
-            mIcon = iconsSet.getIcon(style.getInt(
-                    keyAttr, R.styleable.Keyboard_Key_keyIcon,
                 KeyboardIconsSet.ICON_UNDEFINED));
         final int shiftedIconId = style.getInt(keyAttr, R.styleable.Keyboard_Key_keyIconShifted,
                 KeyboardIconsSet.ICON_UNDEFINED);
@@ -370,10 +360,9 @@ public class Key {
         } else {
             mCode = Keyboard.CODE_DUMMY;
         }
-        } finally {
+
         keyAttr.recycle();
     }
-    }
 
     public void addEdgeFlags(int flags) {
         mEdgeFlags |= flags;

java/src/com/android/inputmethod/keyboard/internal/KeyboardBuilder.java

@@ -218,14 +218,14 @@ public class KeyboardBuilder<KP extends KeyboardParams> {
             final int displayHeight = mDisplayMetrics.heightPixels;
             final int keyboardHeight = (int)keyboardAttr.getDimension(
                     R.styleable.Keyboard_keyboardHeight, displayHeight / 2);
-            final int maxKeyboardHeight = getDimensionOrFraction(keyboardAttr,
+            final int maxKeyboardHeight = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_maxKeyboardHeight, displayHeight, displayHeight / 2);
-            int minKeyboardHeight = getDimensionOrFraction(keyboardAttr,
+            int minKeyboardHeight = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_minKeyboardHeight, displayHeight, displayHeight / 2);
             if (minKeyboardHeight < 0) {
                 // Specified fraction was negative, so it should be calculated against display
                 // width.
-                minKeyboardHeight = -getDimensionOrFraction(keyboardAttr,
+                minKeyboardHeight = -(int)getDimensionOrFraction(keyboardAttr,
                         R.styleable.Keyboard_minKeyboardHeight, displayWidth, displayWidth / 2);
             }
             // Keyboard height will not exceed maxKeyboardHeight and will not be less than
@@ -233,9 +233,9 @@ public class KeyboardBuilder<KP extends KeyboardParams> {
             mParams.mOccupiedHeight = Math.max(
                     Math.min(keyboardHeight, maxKeyboardHeight), minKeyboardHeight);
             mParams.mOccupiedWidth = mParams.mId.mWidth;
-            mParams.mTopPadding = getDimensionOrFraction(keyboardAttr,
+            mParams.mTopPadding = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_keyboardTopPadding, mParams.mOccupiedHeight, 0);
-            mParams.mBottomPadding = getDimensionOrFraction(keyboardAttr,
+            mParams.mBottomPadding = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_keyboardBottomPadding, mParams.mOccupiedHeight, 0);
 
             final int height = mParams.mOccupiedHeight;
@@ -243,13 +243,13 @@ public class KeyboardBuilder<KP extends KeyboardParams> {
                     - mParams.mHorizontalCenterPadding;
             mParams.mHeight = height;
             mParams.mWidth = width;
-            mParams.mDefaultKeyWidth = getDimensionOrFraction(keyboardAttr,
+            mParams.mDefaultKeyWidth = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_keyWidth, width, width / 10);
-            mParams.mDefaultRowHeight = getDimensionOrFraction(keyboardAttr,
+            mParams.mDefaultRowHeight = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_rowHeight, height, height / 4);
-            mParams.mHorizontalGap = getDimensionOrFraction(keyboardAttr,
+            mParams.mHorizontalGap = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_horizontalGap, width, 0);
-            mParams.mVerticalGap = getDimensionOrFraction(keyboardAttr,
+            mParams.mVerticalGap = (int)getDimensionOrFraction(keyboardAttr,
                     R.styleable.Keyboard_verticalGap, height, 0);
 
             mParams.mIsRtlKeyboard = keyboardAttr.getBoolean(
@@ -384,13 +384,13 @@ public class KeyboardBuilder<KP extends KeyboardParams> {
             if (keyboardAttr.hasValue(R.styleable.Keyboard_horizontalGap))
                 throw new IllegalAttribute(parser, "horizontalGap");
             final int keyboardWidth = mParams.mWidth;
-            final int keyWidth = getDimensionOrFraction(keyboardAttr, R.styleable.Keyboard_keyWidth,
+            final float keyWidth = getDimensionOrFraction(keyboardAttr,
-                    keyboardWidth, row.mDefaultKeyWidth);
+                    R.styleable.Keyboard_keyWidth, keyboardWidth, row.mDefaultKeyWidth);
             keyboardAttr.recycle();
 
             final TypedArray keyAttr = mResources.obtainAttributes(Xml.asAttributeSet(parser),
                     R.styleable.Keyboard_Key);
-            int keyXPos = KeyboardBuilder.getDimensionOrFraction(keyAttr,
+            float keyXPos = getDimensionOrFraction(keyAttr,
                     R.styleable.Keyboard_Key_keyXPos, keyboardWidth, row.mCurrentX);
             if (keyXPos < 0) {
                 // If keyXPos is negative, the actual x-coordinate will be display_width + keyXPos.
@@ -688,24 +688,23 @@ public class KeyboardBuilder<KP extends KeyboardParams> {
     private void endKeyboard() {
     }
 
-    private void setSpacer(int keyXPos, int width, Row row) {
+    private void setSpacer(float keyXPos, float width, Row row) {
         row.mCurrentX = keyXPos + width;
         mLeftEdge = false;
         mRightEdgeKey = null;
     }
 
-    public static int getDimensionOrFraction(TypedArray a, int index, int base, int defValue) {
+    public static float getDimensionOrFraction(TypedArray a, int index, int base, float defValue) {
         final TypedValue value = a.peekValue(index);
         if (value == null)
             return defValue;
         if (isFractionValue(value)) {
-            // Round it to avoid values like 47.9999 from getting truncated
+            return a.getFraction(index, base, base, defValue);
-            return Math.round(a.getFraction(index, base, base, defValue));
         } else if (isDimensionValue(value)) {
-            return a.getDimensionPixelOffset(index, defValue);
+            return a.getDimension(index, defValue);
         } else if (isIntegerValue(value)) {
             // For enum value.
-            return a.getInt(index, defValue);
+            return a.getInt(index, 0);
         }
         return defValue;
     }

java/src/com/android/inputmethod/keyboard/internal/Row.java

@@ -31,13 +31,13 @@ import com.android.inputmethod.latin.R;
  */
 public class Row {
     /** Default width of a key in this row. */
-    public final int mDefaultKeyWidth;
+    public final float mDefaultKeyWidth;
     /** Default height of a key in this row. */
     public final int mRowHeight;
 
     public final int mCurrentY;
     // Will be updated by {@link Key}'s constructor.
-    public int mCurrentX;
+    public float mCurrentX;
 
     public Row(Resources res, KeyboardParams params, XmlResourceParser parser, int y) {
         final int keyboardWidth = params.mWidth;
@@ -46,11 +46,11 @@ public class Row {
                 R.styleable.Keyboard);
         mDefaultKeyWidth = KeyboardBuilder.getDimensionOrFraction(a,
                 R.styleable.Keyboard_keyWidth, keyboardWidth, params.mDefaultKeyWidth);
-        mRowHeight = KeyboardBuilder.getDimensionOrFraction(a,
+        mRowHeight = (int)KeyboardBuilder.getDimensionOrFraction(a,
                 R.styleable.Keyboard_rowHeight, keyboardHeight, params.mDefaultRowHeight);
         a.recycle();
 
         mCurrentY = y;
-        mCurrentX = 0;
+        mCurrentX = 0.0f;
     }
 }