Draw a NativeTextfieldViews drop location cursor.

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"
@@ skipping 161 matching lines @@
   *formats = ui::OSExchangeData::STRING;
   return true;
 }
 
 bool NativeTextfieldViews::CanDrop(const OSExchangeData& data) {
   return textfield_->IsEnabled() && !textfield_->read_only() &&
          data.HasString();
 }
 
 int NativeTextfieldViews::OnDragUpdated(const DropTargetEvent& event) {
-  // TODO(msw): retain unfocused selection, render secondary cursor...
   DCHECK(CanDrop(event.data()));
+  bool is_point_in_selection = IsPointInSelection(event.location());
+  is_drop_cursor_visible_ = !is_point_in_selection;
+  // TODO(msw): Pan over text when the user drags to the visible text edge.
+  UpdateCursorBoundsAndTextOffset(FindCursorPosition(event.location()), true);
+  SchedulePaint();
+
   if (initiating_drag_) {
-    if (IsPointInSelection(event.location()))
+    if (is_point_in_selection)
       return ui::DragDropTypes::DRAG_NONE;
     return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY :
                                    ui::DragDropTypes::DRAG_MOVE;
   }
   return ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE;
 }
 
 int NativeTextfieldViews::OnPerformDrop(const DropTargetEvent& event) {
   DCHECK(CanDrop(event.data()));
   DCHECK(!initiating_drag_ || !IsPointInSelection(event.location()));
@@ skipping 22 matching lines @@
     model_->InsertText(text);
   }
   skip_input_method_cancel_composition_ = false;
   UpdateAfterChange(true, true);
   OnAfterUserAction();
   return move ? ui::DragDropTypes::DRAG_MOVE : ui::DragDropTypes::DRAG_COPY;
 }
 
 void NativeTextfieldViews::OnDragDone() {
   initiating_drag_ = false;
+  is_drop_cursor_visible_ = false;
 }
 
 void NativeTextfieldViews::OnPaint(gfx::Canvas* canvas) {
   text_border_->set_has_focus(textfield_->HasFocus());
   OnPaintBackground(canvas);
   PaintTextAndCursor(canvas);
   if (textfield_->draw_border())
     OnPaintBorder(canvas);
 }
 
@@ skipping 57 matching lines @@
 
 /////////////////////////////////////////////////////////////////
 // NativeTextfieldViews, NativeTextifieldWrapper overrides:
 
 string16 NativeTextfieldViews::GetText() const {
   return model_->text();
 }
 
 void NativeTextfieldViews::UpdateText() {
   model_->SetText(textfield_->text());
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
   SchedulePaint();
 }
 
 void NativeTextfieldViews::AppendText(const string16& text) {
   if (text.empty())
     return;
   model_->Append(text);
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
   SchedulePaint();
 }
 
 string16 NativeTextfieldViews::GetSelectedText() const {
   return model_->GetSelectedText();
 }
 
 void NativeTextfieldViews::SelectAll() {
   model_->SelectAll();
   SchedulePaint();
@@ skipping 25 matching lines @@
       Background::CreateSolidBackground(textfield_->background_color()));
   SchedulePaint();
 }
 
 void NativeTextfieldViews::UpdateReadOnly() {
   SchedulePaint();
   OnTextInputTypeChanged();
 }
 
 void NativeTextfieldViews::UpdateFont() {
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
 }
 
 void NativeTextfieldViews::UpdateIsPassword() {
   model_->set_is_password(textfield_->IsPassword());
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
   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;
   gfx::Insets inset = GetInsets();
 
   text_border_->SetInsets(inset.top(), left, inset.bottom(), right);
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
 }
 
 void NativeTextfieldViews::UpdateVerticalMargins() {
   int top, bottom;
   if (!textfield_->GetVerticalMargins(&top, &bottom))
     return;
   gfx::Insets inset = GetInsets();
 
   text_border_->SetInsets(top, inset.left(), bottom, inset.right());
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
 }
 
 bool NativeTextfieldViews::SetFocus() {
   return false;
 }
 
 View* NativeTextfieldViews::GetView() {
   return this;
 }
 
 gfx::NativeView NativeTextfieldViews::GetTestingHandle() const {
   NOTREACHED();
   return NULL;
 }
 
 bool NativeTextfieldViews::IsIMEComposing() const {
   return model_->HasCompositionText();
 }
 
 void NativeTextfieldViews::GetSelectedRange(ui::Range* range) const {
   model_->GetSelectedRange(range);
 }
 
 void NativeTextfieldViews::SelectRange(const ui::Range& range) {
   model_->SelectRange(range);
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
   SchedulePaint();
 }
 
 size_t NativeTextfieldViews::GetCursorPosition() const {
   return model_->cursor_pos();
 }
 
 bool NativeTextfieldViews::HandleKeyPressed(const KeyEvent& e) {
   TextfieldController* controller = textfield_->GetController();
   bool handled = false;
@@ skipping 124 matching lines @@
   return textfield_view_enabled || Widget::IsPureViews();
 #endif
 }
 
 // static
 void NativeTextfieldViews::SetEnableTextfieldViews(bool enabled) {
   textfield_view_enabled = enabled;
 }
 
 void NativeTextfieldViews::OnBoundsChanged(const gfx::Rect& previous_bounds) {
-  UpdateCursorBoundsAndTextOffset();
+  UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // NativeTextfieldViews, TextInputClient implementation, private:
 
 void NativeTextfieldViews::SetCompositionText(
     const ui::CompositionText& composition) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
@@ skipping 176 matching lines @@
       cursor_timer_.NewRunnableMethod(&NativeTextfieldViews::UpdateCursor),
       is_cursor_visible_ ? kCursorVisibleTimeMs : kCursorInvisibleTimeMs);
 }
 
 void NativeTextfieldViews::RepaintCursor() {
   gfx::Rect r = cursor_bounds_;
   r.Inset(-1, -1, -1, -1);
   SchedulePaintInRect(r);
 }
 
-void NativeTextfieldViews::UpdateCursorBoundsAndTextOffset() {
+gfx::Rect NativeTextfieldViews::GetCursorBounds(size_t cursor_pos,
+                                                bool insert_mode) const {
+  string16 text = model_->GetVisibleText();
+  const gfx::Font& font = GetFont();
+  int x = font.GetStringWidth(text.substr(0U, cursor_pos));
+  DCHECK_GE(x, 0);
+  int h = std::min(height() - GetInsets().height(), font.GetHeight());
+  gfx::Rect bounds(x, (height() - h) / 2, 0, h);
+  if (!insert_mode && text.length() != cursor_pos)
+    bounds.set_width(font.GetStringWidth(text.substr(0, cursor_pos + 1)) - x);
+  return bounds;
+}
+
+
+void NativeTextfieldViews::UpdateCursorBoundsAndTextOffset(size_t cursor_pos,
+                                                           bool insert_mode) {
   if (bounds().IsEmpty())
     return;
 
-  gfx::Insets insets = GetInsets();
-
-  int width = bounds().width() - insets.width();
-
   // TODO(oshima): bidi
-  const gfx::Font& font = GetFont();
-  int full_width = font.GetStringWidth(model_->GetVisibleText());
-  int cursor_height = std::min(height() - insets.height(), font.GetHeight());
-
-  cursor_bounds_ = model_->GetCursorBounds(font);
-  cursor_bounds_.set_y((height() - cursor_height) / 2);
-  cursor_bounds_.set_height(cursor_height);
-
-  int x_right = text_offset_ + cursor_bounds_.right();
-  int x_left = text_offset_ + cursor_bounds_.x();
+  int width = bounds().width() - GetInsets().width();
+  int full_width = GetFont().GetStringWidth(model_->GetVisibleText());
+  cursor_bounds_ = GetCursorBounds(cursor_pos, insert_mode);
 
   if (full_width < width) {
     // Show all text whenever the text fits to the size.
     text_offset_ = 0;
-  } else if (x_right > width) {
+  } else if ((text_offset_ + cursor_bounds_.right()) > width) {
     // when the cursor overflows to the right
     text_offset_ = width - cursor_bounds_.right();
-  } else if (x_left < 0) {
+  } else if ((text_offset_ + cursor_bounds_.x()) < 0) {
     // when the cursor overflows to the left
     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());
+  cursor_bounds_.set_x(cursor_bounds_.x() + text_offset_ + GetInsets().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());
@@ skipping 27 matching lines @@
                                            iter->range.end());
     // TODO(oshima): This does not give the accurate position due to
     // kerning. Figure out how to do.
     int width = font.GetStringWidth(text);
     iter->style->DrawString(canvas, text, font, textfield_->read_only(),
                             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.
+  // Paint cursor. Replace cursor is drawn as rectangle for now.
+  if (textfield_->IsEnabled() && (is_drop_cursor_visible_ ||
+      (is_cursor_visible_ && !model_->HasSelection())))
     canvas->DrawRectInt(kCursorColor,
                         cursor_bounds_.x(),
                         cursor_bounds_.y(),
-                        insert_ ? 0 : cursor_bounds_.width(),
+                        cursor_bounds_.width(),
                         cursor_bounds_.height());
-  }
 }
 
 bool NativeTextfieldViews::HandleKeyEvent(const KeyEvent& key_event) {
   // TODO(oshima): Refactor and consolidate with ExecuteCommand.
   if (key_event.type() == ui::ET_KEY_PRESSED) {
     ui::KeyboardCode key_code = key_event.key_code();
     // TODO(oshima): shift-tab does not work. Figure out why and fix.
     if (key_code == ui::VKEY_TAB)
       return false;
 
@@ skipping 140 matching lines @@
 bool NativeTextfieldViews::IsPointInSelection(const gfx::Point& point) const {
   ui::Range range;
   GetSelectedRange(&range);
   size_t pos = FindCursorPosition(point);
   return (pos >= range.GetMin() && pos < range.GetMax());
 }
 
 bool NativeTextfieldViews::MoveCursorTo(const gfx::Point& point, bool select) {
   size_t pos = FindCursorPosition(point);
   if (model_->MoveCursorTo(pos, select)) {
-    UpdateCursorBoundsAndTextOffset();
+    UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
     return true;
   }
   return false;
 }
 
 void NativeTextfieldViews::PropagateTextChange() {
   textfield_->SyncText();
 }
 
 void NativeTextfieldViews::UpdateAfterChange(bool text_changed,
                                              bool cursor_changed) {
   if (text_changed)
     PropagateTextChange();
   if (cursor_changed) {
     is_cursor_visible_ = true;
     RepaintCursor();
   }
   if (text_changed || cursor_changed) {
-    UpdateCursorBoundsAndTextOffset();
+    UpdateCursorBoundsAndTextOffset(model_->cursor_pos(), insert_);
     SchedulePaint();
   }
 }
 
 void NativeTextfieldViews::UpdateContextMenu() {
   if (!context_menu_contents_.get()) {
     context_menu_contents_.reset(new ui::SimpleMenuModel(this));
     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);
@@ skipping 53 matching lines @@
   // Filter out all control characters, including tab and new line characters,
   // and all characters with Alt modifier. But we need to allow characters with
   // AltGr modifier.
   // On Windows AltGr is represented by Alt+Ctrl, and on Linux it's a different
   // flag that we don't care about.
   return ((ch >= 0x20 && ch < 0x7F) || ch > 0x9F) &&
       (flags & ~(ui::EF_SHIFT_DOWN | ui::EF_CAPS_LOCK_DOWN)) != ui::EF_ALT_DOWN;
 }
 
 }  // namespace views