Integrate the new input method API for Views into Chromium.

views/controls/textfield/native_textfield_views.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/controls/textfield/native_textfield_views.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "grit/app_strings.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/range/range.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/insets.h"
 #include "views/background.h"
 #include "views/border.h"
 #include "views/controls/menu/menu_2.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/controls/textfield/textfield_controller.h"
 #include "views/controls/textfield/textfield_views_model.h"
 #include "views/events/event.h"
+#include "views/ime/input_method.h"
 #include "views/metrics.h"
 #include "views/views_delegate.h"
 
 #if defined(OS_LINUX)
 #include "ui/gfx/gtk_util.h"
 #endif
 
 namespace {
 
 // A global flag to switch the Textfield wrapper to TextfieldViews.
@@ skipping 18 matching lines @@
 const char kEnableViewsBasedTextfieldSwitch[] = "enable-textfield-views";
 }  // namespace
 
 namespace views {
 
 const char NativeTextfieldViews::kViewClassName[] =
     "views/NativeTextfieldViews";
 
 NativeTextfieldViews::NativeTextfieldViews(Textfield* parent)
     : textfield_(parent),
-      model_(new TextfieldViewsModel()),
+      ALLOW_THIS_IN_INITIALIZER_LIST(model_(new TextfieldViewsModel(this))),
       text_border_(new TextfieldBorder()),
       text_offset_(0),
       insert_(true),
       is_cursor_visible_(false),
+      skip_input_method_cancel_composition_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(cursor_timer_(this)),
       last_mouse_press_time_(base::Time::FromInternalValue(0)),
       click_state_(NONE) {
   set_border(text_border_);
 
   // Multiline is not supported.
   DCHECK_NE(parent->style(), Textfield::STYLE_MULTILINE);
   // Lowercase is not supported.
   DCHECK_NE(parent->style(), Textfield::STYLE_LOWERCASE);
 
@@ skipping 78 matching lines @@
 }
 
 /////////////////////////////////////////////////////////////////
 // NativeTextfieldViews, NativeTextifieldWrapper overrides:
 
 string16 NativeTextfieldViews::GetText() const {
   return model_->text();
 }
 
 void NativeTextfieldViews::UpdateText() {
-  bool changed = model_->SetText(textfield_->text());
+  model_->SetText(textfield_->text());
   UpdateCursorBoundsAndTextOffset();
   SchedulePaint();
-  if (changed) {
-    TextfieldController* controller = textfield_->GetController();
-    if (controller)
-      controller->ContentsChanged(textfield_, GetText());
-  }
 }
 
 void NativeTextfieldViews::AppendText(const string16& text) {
   if (text.empty())
     return;
   model_->Append(text);
   UpdateCursorBoundsAndTextOffset();
   SchedulePaint();
-
-  TextfieldController* controller = textfield_->GetController();
-  if (controller)
-    controller->ContentsChanged(textfield_, GetText());
 }
 
 string16 NativeTextfieldViews::GetSelectedText() const {
   return model_->GetSelectedText();
 }
 
 void NativeTextfieldViews::SelectAll() {
   model_->SelectAll();
   SchedulePaint();
 }
@@ skipping 20 matching lines @@
 
 void NativeTextfieldViews::UpdateBackgroundColor() {
   // TODO(oshima): Background has to match the border's shape.
   set_background(
       Background::CreateSolidBackground(textfield_->background_color()));
   SchedulePaint();
 }
 
 void NativeTextfieldViews::UpdateReadOnly() {
   SchedulePaint();
+  OnTextInputTypeChanged();
 }
 
 void NativeTextfieldViews::UpdateFont() {
   UpdateCursorBoundsAndTextOffset();
 }
 
 void NativeTextfieldViews::UpdateIsPassword() {
   model_->set_is_password(textfield_->IsPassword());
   UpdateCursorBoundsAndTextOffset();
   SchedulePaint();
+  OnTextInputTypeChanged();
 }
 
 void NativeTextfieldViews::UpdateEnabled() {
   SetEnabled(textfield_->IsEnabled());
   SchedulePaint();
+  OnTextInputTypeChanged();
 }
 
 gfx::Insets NativeTextfieldViews::CalculateInsets() {
   return GetInsets();
 }
 
 void NativeTextfieldViews::UpdateHorizontalMargins() {
   int left, right;
   if (!textfield_->GetHorizontalMargins(&left, &right))
     return;
@@ skipping 20 matching lines @@
 View* NativeTextfieldViews::GetView() {
   return this;
 }
 
 gfx::NativeView NativeTextfieldViews::GetTestingHandle() const {
   NOTREACHED();
   return NULL;
 }
 
 bool NativeTextfieldViews::IsIMEComposing() const {
-  return false;
+  return model_->HasCompositionText();
 }
 
 void NativeTextfieldViews::GetSelectedRange(ui::Range* range) const {
   model_->GetSelectedRange(range);
 }
 
 void NativeTextfieldViews::SelectRange(const ui::Range& range) {
   model_->SelectRange(range);
   UpdateCursorBoundsAndTextOffset();
   SchedulePaint();
@@ skipping 11 matching lines @@
   return handled || HandleKeyEvent(e);
 }
 
 bool NativeTextfieldViews::HandleKeyReleased(const views::KeyEvent& e) {
   return true;
 }
 
 void NativeTextfieldViews::HandleFocus() {
   is_cursor_visible_ = true;
   SchedulePaint();
+  OnCaretBoundsChanged();
   // Start blinking cursor.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       cursor_timer_.NewRunnableMethod(&NativeTextfieldViews::UpdateCursor),
       kCursorVisibleTimeMs);
 }
 
 void NativeTextfieldViews::HandleBlur() {
   // Stop blinking cursor.
   cursor_timer_.RevokeAll();
   if (is_cursor_visible_) {
     is_cursor_visible_ = false;
     RepaintCursor();
   }
 }
 
+TextInputClient* NativeTextfieldViews::GetTextInputClient() {
+  return textfield_->read_only() ? NULL : this;
+}
+
 /////////////////////////////////////////////////////////////////
 // NativeTextfieldViews, ui::SimpleMenuModel::Delegate overrides:
 
 bool NativeTextfieldViews::IsCommandIdChecked(int command_id) const {
   return true;
 }
 
 bool NativeTextfieldViews::IsCommandIdEnabled(int command_id) const {
   bool editable = !textfield_->read_only();
   string16 result;
@@ skipping 69 matching lines @@
 void NativeTextfieldViews::SetEnableTextfieldViews(bool enabled) {
   textfield_view_enabled = enabled;
 }
 
 void NativeTextfieldViews::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   UpdateCursorBoundsAndTextOffset();
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// NativeTextfieldViews private:
+// NativeTextfieldViews, TextInputClient implementation, private:
+
+void NativeTextfieldViews::SetCompositionText(
+    const ui::CompositionText& composition) {
+  if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
+    return;
+
+  OnBeforeUserAction();
+  skip_input_method_cancel_composition_ = true;
+  model_->SetCompositionText(composition);
+  skip_input_method_cancel_composition_ = false;
+  UpdateAfterChange(true, true);
+  OnAfterUserAction();
+}
+
+void NativeTextfieldViews::ConfirmCompositionText() {
+  if (!model_->HasCompositionText())
+    return;
+
+  OnBeforeUserAction();
+  skip_input_method_cancel_composition_ = true;
+  model_->ConfirmCompositionText();
+  skip_input_method_cancel_composition_ = false;
+  UpdateAfterChange(true, true);
+  OnAfterUserAction();
+}
+
+void NativeTextfieldViews::ClearCompositionText() {
+  if (!model_->HasCompositionText())
+    return;
+
+  OnBeforeUserAction();
+  skip_input_method_cancel_composition_ = true;
+  model_->ClearCompositionText();
+  skip_input_method_cancel_composition_ = false;
+  UpdateAfterChange(true, true);
+  OnAfterUserAction();
+}
+
+void NativeTextfieldViews::InsertText(const string16& text) {
+  // TODO(suzhe): Filter invalid characters.
+  if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE || text.empty())
+    return;
+
+  OnBeforeUserAction();
+  skip_input_method_cancel_composition_ = true;
+  if (insert_)
+    model_->InsertText(text);
+  else
+    model_->ReplaceText(text);
+  skip_input_method_cancel_composition_ = false;
+  UpdateAfterChange(true, true);
+  OnAfterUserAction();
+}
+
+void NativeTextfieldViews::InsertChar(char16 ch, int flags) {
+  if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE ||
+      !ShouldInsertChar(ch, flags)) {
+    return;
+  }
+
+  OnBeforeUserAction();
+  skip_input_method_cancel_composition_ = true;
+  if (insert_)
+    model_->InsertChar(ch);
+  else
+    model_->ReplaceChar(ch);
+  skip_input_method_cancel_composition_ = false;
+  UpdateAfterChange(true, true);
+  OnAfterUserAction();
+}
+
+ui::TextInputType NativeTextfieldViews::GetTextInputType() {
+  if (textfield_->read_only() || !textfield_->IsEnabled())
+    return ui::TEXT_INPUT_TYPE_NONE;
+  else if (textfield_->IsPassword())
+    return ui::TEXT_INPUT_TYPE_PASSWORD;
+  return ui::TEXT_INPUT_TYPE_TEXT;
+}
+
+gfx::Rect NativeTextfieldViews::GetCaretBounds() {
+  return cursor_bounds_;
+}
+
+bool NativeTextfieldViews::HasCompositionText() {
+  return model_->HasCompositionText();
+}
+
+bool NativeTextfieldViews::GetTextRange(ui::Range* range) {
+  // We don't allow the input method to retrieve or delete content from a
+  // password box.
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT)
+    return false;
+
+  model_->GetTextRange(range);
+  return true;
+}
+
+bool NativeTextfieldViews::GetCompositionTextRange(ui::Range* range) {
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT)
+    return false;
+
+  model_->GetCompositionTextRange(range);
+  return true;
+}
+
+bool NativeTextfieldViews::GetSelectionRange(ui::Range* range) {
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT)
+    return false;
+
+  model_->GetSelectedRange(range);
+  return true;
+}
+
+bool NativeTextfieldViews::SetSelectionRange(const ui::Range& range) {
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT || !range.IsValid())
+    return false;
+
+  OnBeforeUserAction();
+  SelectRange(range);
+  OnAfterUserAction();
+  return true;
+}
+
+bool NativeTextfieldViews::DeleteRange(const ui::Range& range) {
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT || range.is_empty())
+    return false;
+
+  OnBeforeUserAction();
+  model_->SelectRange(range);
+  if (model_->HasSelection()) {
+    model_->DeleteSelection();
+    UpdateAfterChange(true, true);
+  }
+  OnAfterUserAction();
+  return true;
+}
+
+bool NativeTextfieldViews::GetTextFromRange(
+    const ui::Range& range,
+    const base::Callback<void(const string16&)>& callback) {
+  if (GetTextInputType() != ui::TEXT_INPUT_TYPE_TEXT || range.is_empty())
+    return false;
+
+  callback.Run(model_->GetTextFromRange(range));
+  return true;
+}
+
+void NativeTextfieldViews::OnInputMethodChanged() {
+  NOTIMPLEMENTED();
+}
+
+bool NativeTextfieldViews::ChangeTextDirectionAndLayoutAlignment(
+    base::i18n::TextDirection direction) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void NativeTextfieldViews::OnCompositionTextConfirmedOrCleared() {
+  if (skip_input_method_cancel_composition_ || !textfield_->HasFocus())
+    return;
+
+  InputMethod* input_method = textfield_->GetInputMethod();
+  if (input_method)
+    input_method->CancelComposition(textfield_);
+}
 
 const gfx::Font& NativeTextfieldViews::GetFont() const {
   return textfield_->font();
 }
 
 SkColor NativeTextfieldViews::GetTextColor() const {
   return textfield_->text_color();
 }
 
 void NativeTextfieldViews::UpdateCursor() {
@@ skipping 39 matching lines @@
     text_offset_ = -cursor_bounds_.x();
   } else if(full_width > width && text_offset_ + full_width < width) {
     // when the cursor moves within the textfield with the text
     // longer than the field.
     text_offset_ = width - full_width;
   } else {
     // move cursor freely.
   }
   // shift cursor bounds to fit insets.
   cursor_bounds_.set_x(cursor_bounds_.x() + text_offset_ + insets.left());
+
+  OnCaretBoundsChanged();
 }
 
 void NativeTextfieldViews::PaintTextAndCursor(gfx::Canvas* canvas) {
   gfx::Insets insets = GetInsets();
 
   canvas->Save();
   canvas->ClipRectInt(insets.left(), insets.top(),
                       width() - insets.width(), height() - insets.height());
 
   // TODO(oshima): bidi support
   // TODO(varunjain): re-implement this so only that dirty text is painted.
   TextfieldViewsModel::TextFragments fragments;
   model_->GetFragments(&fragments);
   int x_offset = text_offset_ + insets.left();
   int y = insets.top();
   int text_height = height() - insets.height();
   SkColor selection_color =
       textfield_->HasFocus() ?
       kFocusedSelectionColor : kUnfocusedSelectionColor;
   SkColor text_color =
       textfield_->read_only() ? kReadonlyTextColor : GetTextColor();
 
   for (TextfieldViewsModel::TextFragments::const_iterator iter =
            fragments.begin();
        iter != fragments.end();
        iter++) {
-    string16 text = model_->GetVisibleText((*iter).begin, (*iter).end);
+    string16 text = model_->GetVisibleText(iter->start, iter->end);
+
+    gfx::Font font = GetFont();
+    if (iter->underline)
+      font = font.DeriveFont(0, font.GetStyle() | gfx::Font::UNDERLINED);
+
     // TODO(oshima): This does not give the accurate position due to
     // kerning. Figure out how webkit does this with skia.
-    int width = GetFont().GetStringWidth(text);
+    int width = font.GetStringWidth(text);
 
-    if ((*iter).selected) {
+    if (iter->selected) {
       canvas->FillRectInt(selection_color, x_offset, y, width, text_height);
-      canvas->DrawStringInt(text, GetFont(), kSelectedTextColor,
+      canvas->DrawStringInt(text, font, kSelectedTextColor,
                             x_offset, y, width, text_height);
     } else {
-      canvas->DrawStringInt(text, GetFont(), text_color,
+      canvas->DrawStringInt(text, font, text_color,
                             x_offset, y, width, text_height);
     }
     x_offset += width;
   }
   canvas->Restore();
 
   if (textfield_->IsEnabled() && is_cursor_visible_ &&
       !model_->HasSelection()) {
     // Paint Cursor. Replace cursor is drawn as rectangle for now.
     canvas->DrawRectInt(kCursorColor,
@@ skipping 45 matching lines @@
       case ui::VKEY_LEFT:
         control ? model_->MoveCursorToPreviousWord(selection)
             : model_->MoveCursorLeft(selection);
         cursor_changed = true;
         break;
       case ui::VKEY_END:
         model_->MoveCursorToEnd(selection);
         cursor_changed = true;
         break;
       case ui::VKEY_HOME:
-        model_->MoveCursorToStart(selection);
+        model_->MoveCursorToHome(selection);
         cursor_changed = true;
         break;
       case ui::VKEY_BACK:
         if (!editable)
           break;
         if (!model_->HasSelection()) {
           if (selection && control) {
             // If both shift and control are pressed, then erase upto the
             // beginning of the buffer in ChromeOS. In windows, do nothing.
 #if defined(OS_WIN)
             break;
 #else
-            model_->MoveCursorToStart(true);
+            model_->MoveCursorToHome(true);
 #endif
           } else if (control) {
             // If only control is pressed, then erase the previous word.
             model_->MoveCursorToPreviousWord(true);
           }
         }
         text_changed = model_->Backspace();
         cursor_changed = true;
         break;
       case ui::VKEY_DELETE:
@@ skipping 15 matching lines @@
         }
         cursor_changed = text_changed = model_->Delete();
         break;
       case ui::VKEY_INSERT:
         insert_ = !insert_;
         cursor_changed = true;
         break;
       default:
         break;
     }
-    char16 ch = key_event.GetCharacter();
-    if (editable && ShouldInsertChar(ch, key_event.flags())) {
-      if (insert_)
-        model_->Insert(ch);
-      else
-        model_->Replace(ch);
-      text_changed = true;
+
+    // Only handle text input by ourselves if there is no input method.
+    if (!textfield_->GetInputMethod()) {
+      char16 ch = key_event.GetCharacter();
+      if (editable && ShouldInsertChar(ch, key_event.flags())) {
+        if (insert_)
+          model_->InsertChar(ch);
+        else
+          model_->ReplaceChar(ch);
+        text_changed = true;
+      }
     }
 
     UpdateAfterChange(text_changed, cursor_changed);
     OnAfterUserAction();
     return (text_changed || cursor_changed);
   }
   return false;
 }
 
 size_t NativeTextfieldViews::FindCursorPosition(const gfx::Point& point) const {
@@ skipping 64 matching lines @@
 
 void NativeTextfieldViews::SetCursorForMouseClick(const views::MouseEvent& e) {
   size_t pos = FindCursorPosition(e.location());
   if (model_->MoveCursorTo(pos, false)) {
     UpdateCursorBoundsAndTextOffset();
   }
 }
 
 void NativeTextfieldViews::PropagateTextChange() {
   textfield_->SyncText();
-  TextfieldController* controller = textfield_->GetController();
-  if (controller)
-    controller->ContentsChanged(textfield_, GetText());
 }
 
 void NativeTextfieldViews::UpdateAfterChange(bool text_changed,
                                              bool cursor_changed) {
   if (text_changed)
     PropagateTextChange();
   if (cursor_changed) {
     is_cursor_visible_ = true;
     RepaintCursor();
   }
@@ skipping 10 matching lines @@
   context_menu_contents_->AddItemWithStringId(IDS_APP_CUT, IDS_APP_CUT);
   context_menu_contents_->AddItemWithStringId(IDS_APP_COPY, IDS_APP_COPY);
   context_menu_contents_->AddItemWithStringId(IDS_APP_PASTE, IDS_APP_PASTE);
   context_menu_contents_->AddItemWithStringId(IDS_APP_DELETE, IDS_APP_DELETE);
   context_menu_contents_->AddSeparator();
   context_menu_contents_->AddItemWithStringId(IDS_APP_SELECT_ALL,
                                               IDS_APP_SELECT_ALL);
   context_menu_menu_.reset(new Menu2(context_menu_contents_.get()));
 }
 
+void NativeTextfieldViews::OnTextInputTypeChanged() {
+  if (!textfield_->HasFocus())
+    return;
+
+  InputMethod* input_method = textfield_->GetInputMethod();
+  if (input_method)
+    input_method->OnTextInputTypeChanged(textfield_);
+}
+
+void NativeTextfieldViews::OnCaretBoundsChanged() {
+  if (!textfield_->HasFocus())
+    return;
+
+  InputMethod* input_method = textfield_->GetInputMethod();
+  if (input_method)
+    input_method->OnCaretBoundsChanged(textfield_);
+}
+
 void NativeTextfieldViews::OnBeforeUserAction() {
   TextfieldController* controller = textfield_->GetController();
   if (controller)
     controller->OnBeforeUserAction(textfield_);
 }
 
 void NativeTextfieldViews::OnAfterUserAction() {
   TextfieldController* controller = textfield_->GetController();
   if (controller)
     controller->OnAfterUserAction(textfield_);
@@ skipping 58 matching lines @@
 }
 
 void NativeTextfieldViews::TextfieldBorder::SetInsets(int top,
                                                       int left,
                                                       int bottom,
                                                       int right) {
   insets_.Set(top, left, bottom, right);
 }
 
 }  // namespace views