diff --git a/java/src/com/android/inputmethod/latin/RichInputConnection.java b/java/src/com/android/inputmethod/latin/RichInputConnection.java
index f77d6860ed54c4c256d5e594ab483cfb7230000f..43b9ba7a99971b8fb4e65d5435854aaa53af997f 100644
--- a/java/src/com/android/inputmethod/latin/RichInputConnection.java
+++ b/java/src/com/android/inputmethod/latin/RichInputConnection.java
@@ -204,8 +204,7 @@ public class RichInputConnection {
}
// This never calls InputConnection#getCapsMode - in fact, it's a static method that
// never blocks or initiates IPC.
- return StringUtils.getCapsMode(mCommittedTextBeforeComposingText,
- mCommittedTextBeforeComposingText.length(), inputType);
+ return StringUtils.getCapsMode(mCommittedTextBeforeComposingText, inputType);
}
public CharSequence getTextBeforeCursor(final int i, final int j) {
diff --git a/java/src/com/android/inputmethod/latin/StringUtils.java b/java/src/com/android/inputmethod/latin/StringUtils.java
index d6509d6a61957566552d4895c5dae02360aa0c7a..4dec7881ba098e6afcb988a4bd92b844eebeedcb 100644
--- a/java/src/com/android/inputmethod/latin/StringUtils.java
+++ b/java/src/com/android/inputmethod/latin/StringUtils.java
@@ -208,7 +208,6 @@ public final class StringUtils {
* issues). This will change in the future as we simplify the code for our use and fix bugs.
*
* @param cs The text that should be checked for caps modes.
- * @param off Location in the text at which to check.
* @param reqModes The modes to be checked: may be any combination of
* {@link #CAP_MODE_CHARACTERS}, {@link #CAP_MODE_WORDS}, and
* {@link #CAP_MODE_SENTENCES}.
@@ -218,52 +217,93 @@ public final class StringUtils {
* {@link #CAP_MODE_CHARACTERS}, {@link #CAP_MODE_WORDS}, and
* {@link #CAP_MODE_SENTENCES}.
*/
- public static int getCapsMode(CharSequence cs, int off, int reqModes) {
- if (off < 0) {
- return 0;
- }
-
+ public static int getCapsMode(CharSequence cs, int reqModes) {
int i;
char c;
int mode = 0;
+ // Quick description of what we want to do:
+ // CAP_MODE_CHARACTERS is always on.
+ // CAP_MODE_WORDS is on if there is some whitespace before the cursor.
+ // CAP_MODE_SENTENCES is on if there is some whitespace before the cursor, and the end
+ // of a sentence just before that.
+ // We ignore opening parentheses and the like just before the cursor for purposes of
+ // finding whitespace for WORDS and SENTENCES modes.
+ // The end of a sentence ends with a period, question mark or exclamation mark. If it's
+ // a period, it also needs not to be an abbreviation, which means it also needs to either
+ // be immediately preceded by punctuation, or by a string of only letters with single
+ // periods interleaved.
+
+ // Step 1 : check for cap mode characters. If it's looked for, it's always on.
if ((reqModes & TextUtils.CAP_MODE_CHARACTERS) != 0) {
mode |= TextUtils.CAP_MODE_CHARACTERS;
}
if ((reqModes & (TextUtils.CAP_MODE_WORDS | TextUtils.CAP_MODE_SENTENCES)) == 0) {
+ // Here we are not looking for words or sentences modes, so since we already evaluated
+ // mode characters, we can return.
return mode;
}
- // Back over allowed opening punctuation.
- for (i = off; i > 0; i--) {
+ // Step 2 : Skip (ignore at the end of input) any opening punctuation. This includes
+ // opening parentheses, brackets, opening quotes, everything that *opens* a span of
+ // text in the linguistic sense. In RTL languages, this is still an opening sign, although
+ // it may look like a right parenthesis for example. We also include double quote and
+ // single quote since they aren't start punctuation in the unicode sense, but should still
+ // be skipped for English. TODO: does this depend on the language?
+ for (i = cs.length(); i > 0; i--) {
c = cs.charAt(i - 1);
if (c != '"' && c != '\'' && Character.getType(c) != Character.START_PUNCTUATION) {
break;
}
}
- // Start of paragraph, with optional whitespace.
+ // We are now on the character that precedes any starting punctuation, so in the most
+ // frequent case this will be whitespace or a letter, although it may occasionally be a
+ // start of line, or some symbol.
+
+ // Step 3 : Search for the start of a paragraph. From the starting point computed in step 2,
+ // we go back over any space or tab char sitting there. We find the start of a paragraph
+ // if the first char that's not a space or tab is a start of line (as in, either \n or
+ // start of text).
int j = i;
while (j > 0 && ((c = cs.charAt(j - 1)) == ' ' || c == '\t')) {
j--;
}
if (j == 0 || cs.charAt(j - 1) == '\n') {
+ // Here we know we are at the start of a paragraph, so we turn on word mode.
+ // Note: I think this is entirely buggy. It will return mode words even if the app
+ // didn't request it, and it will fail to return sentence mode even if this is actually
+ // the start of a sentence. As it happens, Latin IME client code considers that mode
+ // word *implies* mode sentence and tests for non-zeroness, so it happens to work.
return mode | TextUtils.CAP_MODE_WORDS;
}
-
- // Or start of word if we are that style.
if ((reqModes & TextUtils.CAP_MODE_SENTENCES) == 0) {
+ // If we don't have to check for mode sentence, then we know all we need to know
+ // already. Either we have whitespace immediately before index i and we are at the
+ // start of a word, or we don't and we aren't. But we just went over any whitespace
+ // just before i and in fact j points before any whitespace, so if i != j that means
+ // there is such whitespace. In this case, we have mode words.
if (i != j) mode |= TextUtils.CAP_MODE_WORDS;
return mode;
}
-
- // There must be a space if not the start of paragraph.
if (i == j) {
+ // Finally, if we don't have whitespace before index i, it means neither mode words
+ // nor mode sentences should be on so we can return right away.
return mode;
}
+ // Please note that because of the reqModes & CAP_MODE_SENTENCES test a few lines above,
+ // we know that mode sentences is being requested.
- // Back over allowed closing punctuation.
+ // Step 4 : Search for sentence mode.
for (; j > 0; j--) {
+ // Here we look to go over any closing punctuation. This is because in dominant variants
+ // of English, the final period is placed within double quotes and maybe other closing
+ // punctuation signs.
+ // TODO: this is wrong for almost everything except American typography rules for
+ // English. It's wrong for British typography rules for English, it's wrong for French,
+ // it's wrong for German, it's wrong for Spanish, and possibly everything else.
+ // (note that American rules and British rules have nothing to do with en_US and en_GB,
+ // as both rules are used in both countries - it's merely a name for the set of rules)
c = cs.charAt(j - 1);
if (c != '"' && c != '\'' && Character.getType(c) != Character.END_PUNCTUATION) {
break;
@@ -273,8 +313,18 @@ public final class StringUtils {
if (j > 0) {
c = cs.charAt(j - 1);
if (c == '.' || c == '?' || c == '!') {
- // Do not capitalize if the word ends with a period but
- // also contains a period, in which case it is an abbreviation.
+ // Here we found a marker for sentence end (we consider these to be one of
+ // either . or ? or ! only). So this is probably the end of a sentence, but if we
+ // found a period, we still want to check the case where this is a abbreviation
+ // period rather than a full stop. To do this, we look for a period within a word
+ // before the period we just found; if any, we take that to mean it was an
+ // abbreviation.
+ // A typical example of the above is "In the U.S. ", where the last period is
+ // not a full stop and we should not capitalize.
+ // TODO: the rule below is broken. In particular it fails for runs of periods,
+ // whatever the reason. In the example "in the U.S..", the last period is a full
+ // stop following the abbreviation period, and we should capitalize but we don't.
+ // Likewise, "I don't know... " should capitalize, but fails to do so.
if (c == '.') {
for (int k = j - 2; k >= 0; k--) {
c = cs.charAt(k);