예제 #1
0
  private static <T> ArrayList<T> arrayAsList(final T[] array, final int start, final int end) {
    if (array == null) {
      throw new NullPointerException();
    }
    if (start < 0 || start > end || end > array.length) {
      throw new IllegalArgumentException();
    }

    final ArrayList<T> list = CollectionUtils.newArrayList(end - start);
    for (int i = start; i < end; i++) {
      list.add(array[i]);
    }
    return list;
  }
예제 #2
0
  /**
   * Split the text containing multiple key specifications separated by commas into an array of key
   * specifications. A key specification can contain a character escaped by the backslash character,
   * including a comma character. Note that an empty key specification will be eliminated from the
   * result array.
   *
   * @param text the text containing multiple key specifications.
   * @return an array of key specification text. Null if the specified <code>text</code> is empty or
   *     has no key specifications.
   */
  public static String[] splitKeySpecs(final String text) {
    final int size = text.length();
    if (size == 0) {
      return null;
    }
    // Optimization for one-letter key specification.
    if (size == 1) {
      return text.charAt(0) == COMMA ? null : new String[] {text};
    }

    ArrayList<String> list = null;
    int start = 0;
    // The characters in question in this loop are COMMA and BACKSLASH. These characters never
    // match any high or low surrogate character. So it is OK to iterate through with char
    // index.
    for (int pos = 0; pos < size; pos++) {
      final char c = text.charAt(pos);
      if (c == COMMA) {
        // Skip empty entry.
        if (pos - start > 0) {
          if (list == null) {
            list = CollectionUtils.newArrayList();
          }
          list.add(text.substring(start, pos));
        }
        // Skip comma
        start = pos + 1;
      } else if (c == BACKSLASH) {
        // Skip escape character and escaped character.
        pos++;
      }
    }
    final String remain = (size - start > 0) ? text.substring(start) : null;
    if (list == null) {
      return remain != null ? new String[] {remain} : null;
    }
    if (remain != null) {
      list.add(remain);
    }
    return list.toArray(new String[list.size()]);
  }
예제 #3
0
public class KeyboardParams {
  public Locale mLocale;
  public int mThemeId;

  /** Total height and width of the keyboard, including the paddings and keys */
  public int mOccupiedHeight;

  public int mOccupiedWidth;

  /** Base height and width of the keyboard used to calculate rows' or keys' heights and widths */
  public int mBaseHeight;

  public int mBaseWidth;

  public int mTopPadding;
  public int mBottomPadding;
  public int mLeftPadding;
  public int mRightPadding;

  public KeyVisualAttributes mKeyVisualAttributes;

  public int mDefaultRowHeight;
  public int mDefaultKeyWidth;
  public int mHorizontalGap;
  public int mVerticalGap;

  public int mMoreKeysTemplate;
  public int mMaxMoreKeysKeyboardColumn;

  public int GRID_WIDTH;
  public int GRID_HEIGHT;

  public final TreeSet<Key> mKeys = CollectionUtils.newTreeSet(); // ordered set
  public final ArrayList<Key> mShiftKeys = CollectionUtils.newArrayList();
  public final ArrayList<Key> mAltCodeKeysWhileTyping = CollectionUtils.newArrayList();
  public final KeyboardIconsSet mIconsSet = new KeyboardIconsSet();
  public final KeyboardCodesSet mCodesSet = new KeyboardCodesSet();
  public final KeyboardTextsSet mTextsSet = new KeyboardTextsSet();
  public final KeyStylesSet mKeyStyles = new KeyStylesSet(mTextsSet);

  public KeysCache mKeysCache;

  public int mMostCommonKeyHeight = 0;
  public int mMostCommonKeyWidth = 0;

  public boolean mProximityCharsCorrectionEnabled;

  public final TouchPositionCorrection mTouchPositionCorrection = new TouchPositionCorrection();

  protected void clearKeys() {
    mKeys.clear();
    mShiftKeys.clear();
    clearHistogram();
  }

  public void onAddKey(final Key newKey) {
    final Key key = (mKeysCache != null) ? mKeysCache.get(newKey) : newKey;
    final boolean isSpacer = key.isSpacer();
    if (isSpacer && key.getWidth() == 0) {
      // Ignore zero width {@link Spacer}.
      return;
    }
    mKeys.add(key);
    if (isSpacer) {
      return;
    }
    updateHistogram(key);
    if (key.getCode() == KeyboardConstants.CODE_SHIFT) {
      mShiftKeys.add(key);
    }
    if (key.altCodeWhileTyping()) {
      mAltCodeKeysWhileTyping.add(key);
    }
  }

  private int mMaxHeightCount = 0;
  private int mMaxWidthCount = 0;
  private final SparseIntArray mHeightHistogram = new SparseIntArray();
  private final SparseIntArray mWidthHistogram = new SparseIntArray();
  public int mHeight;
  public int mWidth;
  public Drawable mDefaultKeyDrawable;

  private void clearHistogram() {
    mMostCommonKeyHeight = 0;
    mMaxHeightCount = 0;
    mHeightHistogram.clear();

    mMaxWidthCount = 0;
    mMostCommonKeyWidth = 0;
    mWidthHistogram.clear();
  }

  private static int updateHistogramCounter(final SparseIntArray histogram, final int key) {
    final int index = histogram.indexOfKey(key);
    final int count = (index >= 0 ? histogram.get(key) : 0) + 1;
    histogram.put(key, count);
    return count;
  }

  private void updateHistogram(final Key key) {
    final int height = key.getHeight() + mVerticalGap;
    final int heightCount = updateHistogramCounter(mHeightHistogram, height);
    if (heightCount > mMaxHeightCount) {
      mMaxHeightCount = heightCount;
      mMostCommonKeyHeight = height;
    }

    final int width = key.getWidth() + mHorizontalGap;
    final int widthCount = updateHistogramCounter(mWidthHistogram, width);
    if (widthCount > mMaxWidthCount) {
      mMaxWidthCount = widthCount;
      mMostCommonKeyWidth = width;
    }
  }
}