Add multi-step input method support for Linux

This updates the platform-independent TextInputModel to add support for
input method (abbreviated IM or IME) composing regions.

In contrast to languages such as English, where keyboard input is
managed keystroke-by-keystroke, languages such as Japanese require a
multi-step input process wherein the user begins a composing sequence,
during which point their keystrokes are captured by a system input
method and converted into a text sequence. During composing, the user is
able to edit the composing range and manage the conversion from keyboard
input to text before eventually committing the text to the underlying
text input field.

To illustrate this, in Japanese, this sequence might look something like
the following:

1. User types 'k'. The character 'k' is added to the composing region.
   Typically, the text 'k' will be inserted inline into the underlying
   text field but the composing range will be highlighted in some manner,
   frequently with a highlight or underline.
2. User types 'a'. The composing range is replaced with the phonetic
   kana character 'か' (ka). The composing range continues to be
   highlighted.
3. User types 'k'. The character 'k' is appended to the composing
   range such that the highlighted text is now 'かｋ'
4. User types 'u'. The trailing 'k' is replaced with the phonetic kana
   character 'く' (ku) such that the composing range now reads 'かく'
   The composing range continues to be highlighted.
5. The user presses the space bar to convert the kana characters to
   kanji. The composing range is replaced with '書く' (kaku: to write).
6. The user presses the space bar again to show other conversions. The
   user's configured input method (for example, ibus) pops up a
   completions menu populated with alternatives such as 各 (kaku:
   every), 描く (kaku: to draw), 核 (kaku: pit of a fruit, nucleus), 角
   (kaku: angle), etc.
7. The user uses the arrow keys to navigate the completions menu and
   select the alternative to input. As they do, the inline composing
   region in the text field is updated. It continues to be highlighted
   or underlined.
8. The user hits enter to commit the composing region. The text is
   committed to the underlying text field and the visual highlighting is
   removed.
9. If the user presses another key, a new composing sequence begins.

If a selection is present when composing begins, it is preserved until
the first keypress of input is received, at which point the selection is
deleted. If a composing sequence is aborted before the first keypress,
the selection is preserved. Creating a new selection (with the mouse,
for example) aborts composing and the composing region is automatically
committed. A composing range and selection, both with an extent, are
not permitted to co-exist.

During composing, keyboard navigation via the arrow keys, or home and
end (or equivalent shortcuts) is restricted to the composing range, as
are deletions via backspace and the delete key.

Author: cbracken

shell/platform/common/cpp/text_input_model.cc

@@ -28,6 +28,11 @@ bool IsTrailingSurrogate(char32_t code_point) {
   return (code_point & 0xFFFFFC00) == 0xDC00;
 }
 
+// Returns true if |x| is between |low| and |high| inclusive.
+bool InRange(size_t x, size_t low, size_t high) {
+  return x >= low && x <= high;
+}
+
 }  // namespace
 
 TextInputModel::TextInputModel() = default;
@@ -40,24 +45,100 @@ void TextInputModel::SetText(const std::string& text) {
   text_ = utf16_converter.from_bytes(text);
   selection_base_ = 0;
   selection_extent_ = 0;
+  composing_base_ = 0;
+  composing_extent_ = 0;
 }
 
 bool TextInputModel::SetSelection(size_t base, size_t extent) {
-  auto max_pos = text_.length();
-  if (base > max_pos || extent > max_pos) {
+  // Only collapsed selections are allowed while composing.
+  if (composing_ && base != extent) {
+    return false;
+  }
+  // Verify the selection is within range.
+  size_t min_pos = composing_ ? composing_start() : 0;
+  size_t max_pos = composing_ ? composing_end() : text_.length();
+  if (!InRange(base, min_pos, max_pos) || !InRange(extent, min_pos, max_pos)) {
     return false;
   }
   selection_base_ = base;
   selection_extent_ = extent;
   return true;
 }
 
-void TextInputModel::DeleteSelected() {
-  text_.erase(selection_start(), selection_end() - selection_start());
-  selection_base_ = selection_start();
+bool TextInputModel::SetComposingRange(size_t base,
+                                       size_t extent,
+                                       size_t cursor_offset) {
+  if (!composing_ || base > text_.length() || extent > text_.length()) {
+    return false;
+  }
+  composing_base_ = base;
+  composing_extent_ = extent;
+  selection_base_ = composing_start() + cursor_offset;
+  selection_extent_ = selection_base_;
+  return true;
+}
+
+void TextInputModel::BeginComposing() {
+  composing_ = true;
+  composing_base_ = selection_start();
+  composing_extent_ = composing_base_;
+}
+
+void TextInputModel::UpdateComposingText(const std::string& composing_text) {
+  std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>
+      utf16_converter;
+  std::u16string text = utf16_converter.from_bytes(composing_text);
+
+  // Preserve selection if we get a no-op update to the composing region.
+  if (text.length() == 0 && composing_base_ == composing_extent_) {
+    return;
+  }
+  if (selection_base_ != selection_extent_) {
+    DeleteSelected();
+  }
+  auto start = composing_start();
+  text_.replace(start, composing_end() - start, text);
+  SetComposingLength(text.length());
+  selection_base_ = composing_end();
   selection_extent_ = selection_base_;
 }
 
+void TextInputModel::CommitComposing() {
+  // Preserve selection if no composing text was entered.
+  if (composing_base_ == composing_extent_) {
+    return;
+  }
+  composing_base_ = composing_extent_;
+  selection_base_ = composing_extent_;
+  selection_extent_ = composing_extent_;
+}
+
+void TextInputModel::EndComposing() {
+  composing_ = false;
+  composing_base_ = 0;
+  composing_extent_ = 0;
+}
+
+void TextInputModel::DeleteSelected() {
+  auto start = selection_start();
+  text_.erase(start, selection_end() - start);
+  selection_base_ = start;
+  selection_extent_ = start;
+  if (composing_) {
+    // This occurs only immediately after composing has begun with a selection.
+    composing_base_ = start;
+    composing_extent_ = start;
+  }
+}
+
+void TextInputModel::SetComposingLength(size_t length) {
+  if (composing_extent_ >= composing_base_) {
+    composing_extent_ = composing_base_ + length;
+  } else {
+    composing_base_ = composing_extent_ + length;
+  }
+}
+
 void TextInputModel::AddCodePoint(char32_t c) {
   if (c <= 0xFFFF) {
     AddText(std::u16string({static_cast<char16_t>(c)}));
@@ -76,6 +157,14 @@ void TextInputModel::AddText(const std::u16string& text) {
   if (selection_base_ != selection_extent_) {
     DeleteSelected();
   }
+  if (composing_) {
+    // Replace the composing text.
+    auto start = composing_start();
+    text_.erase(start, composing_end() - start);
+    selection_base_ = start;
+    selection_extent_ = start;
+    SetComposingLength(text.length());
+  }
   text_.insert(selection_extent_, text);
   selection_extent_ += text.length();
   selection_base_ = selection_extent_;
@@ -94,11 +183,15 @@ bool TextInputModel::Backspace() {
     return true;
   }
   // There's no selection; delete the preceding codepoint.
-  if (selection_base_ != 0) {
+  auto min_pos = composing_ ? composing_start() : 0;
+  if (selection_base_ > min_pos) {
     int count = IsTrailingSurrogate(text_.at(selection_base_ - 1)) ? 2 : 1;
     text_.erase(selection_base_ - count, count);
     selection_base_ -= count;
     selection_extent_ = selection_base_;
+    if (composing_) {
+      SetComposingLength(composing_end() - composing_start() - count);
+    }
     return true;
   }
   return false;
@@ -111,43 +204,50 @@ bool TextInputModel::Delete() {
     return true;
   }
   // There's no selection; delete the following codepoint.
-  if (selection_base_ != text_.length()) {
+  auto max_pos = composing_ ? composing_end() : text_.length();
+  if (selection_base_ < max_pos) {
     int count = IsLeadingSurrogate(text_.at(selection_base_)) ? 2 : 1;
     text_.erase(selection_base_, count);
     selection_extent_ = selection_base_;
+    if (composing_) {
+      SetComposingLength(composing_end() - composing_start() - count);
+    }
     return true;
   }
   return false;
 }
 
 bool TextInputModel::DeleteSurrounding(int offset_from_cursor, int count) {
+  auto min_pos = composing_ ? composing_start() : 0;
+  auto max_pos = composing_ ? composing_end() : text_.length();
   auto start = selection_extent_;
   if (offset_from_cursor < 0) {
     for (int i = 0; i < -offset_from_cursor; i++) {
       // If requested start is before the available text then reduce the
       // number of characters to delete.
-      if (start == 0) {
+      if (start == min_pos) {
         count = i;
         break;
       }
       start -= IsTrailingSurrogate(text_.at(start - 1)) ? 2 : 1;
     }
   } else {
-    for (int i = 0; i < offset_from_cursor && start != text_.length(); i++) {
+    for (int i = 0; i < offset_from_cursor && start != max_pos; i++) {
       start += IsLeadingSurrogate(text_.at(start)) ? 2 : 1;
     }
   }
 
   auto end = start;
-  for (int i = 0; i < count && end != text_.length(); i++) {
+  for (int i = 0; i < count && end != max_pos; i++) {
     end += IsLeadingSurrogate(text_.at(start)) ? 2 : 1;
   }
 
   if (start == end) {
     return false;
   }
 
-  text_.erase(start, end - start);
+  auto deleted_length = end - start;
+  text_.erase(start, deleted_length);
 
   // Cursor moves only if deleted area is before it.
   if (offset_from_cursor <= 0) {
@@ -157,22 +257,32 @@ bool TextInputModel::DeleteSurrounding(int offset_from_cursor, int count) {
   // Clear selection.
   selection_extent_ = selection_base_;
 
+  // Adjust composing range.
+  if (composing_) {
+    SetComposingLength(composing_end() - composing_start() - deleted_length);
+  }
   return true;
 }
 
 bool TextInputModel::MoveCursorToBeginning() {
-  if (selection_base_ == 0 && selection_extent_ == 0)
+  // If we're composing, move to the begining of the composing range, else move
+  // to begging of string.
+  auto min_pos = composing_ ? composing_start() : 0;
+  if (selection_base_ == min_pos && selection_extent_ == min_pos) {
     return false;
-
-  selection_base_ = 0;
-  selection_extent_ = 0;
+  }
+  selection_base_ = min_pos;
+  selection_extent_ = min_pos;
   return true;
 }
 
 bool TextInputModel::MoveCursorToEnd() {
-  auto max_pos = text_.length();
-  if (selection_base_ == max_pos && selection_extent_ == max_pos)
+  // If we're composing, move to the end of the composing range, else move to
+  // end of string.
+  auto max_pos = composing_ ? composing_end() : text_.length();
+  if (selection_base_ == max_pos && selection_extent_ == max_pos) {
     return false;
+  }
 
   selection_base_ = max_pos;
   selection_extent_ = max_pos;
@@ -187,7 +297,8 @@ bool TextInputModel::MoveCursorForward() {
     return true;
   }
   // If not at the end, move the extent forward.
-  if (selection_extent_ != text_.length()) {
+  auto max_pos = composing_ ? composing_end() : text_.length();
+  if (selection_extent_ != max_pos) {
     int count = IsLeadingSurrogate(text_.at(selection_base_)) ? 2 : 1;
     selection_base_ += count;
     selection_extent_ = selection_base_;
@@ -205,7 +316,8 @@ bool TextInputModel::MoveCursorBack() {
     return true;
   }
   // If not at the start, move the beginning backward.
-  if (selection_base_ != 0) {
+  auto min_pos = composing_ ? composing_start() : 0;
+  if (selection_base_ != min_pos) {
     int count = IsTrailingSurrogate(text_.at(selection_base_ - 1)) ? 2 : 1;
     selection_base_ -= count;
     selection_extent_ = selection_base_;