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 49 matching lines @@
 const char NativeTextfieldViews::kViewClassName[] =
     "views/NativeTextfieldViews";
 
 NativeTextfieldViews::NativeTextfieldViews(Textfield* parent)
     : textfield_(parent),
       ALLOW_THIS_IN_INITIALIZER_LIST(model_(new TextfieldViewsModel(this))),
       text_border_(new FocusableBorder()),
       text_offset_(0),
       insert_(true),
       is_cursor_visible_(false),
+      is_drop_cursor_visible_(false),
       skip_input_method_cancel_composition_(false),
       initiating_drag_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(cursor_timer_(this)),
       aggregated_clicks_(0),
       last_click_time_(base::Time::FromInternalValue(0)),
       last_click_location_(0, 0) {
   set_border(text_border_);
 
   // Lowercase is not supported.
   DCHECK_NE(parent->style(), Textfield::STYLE_LOWERCASE);
@@ skipping 90 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;
+  drop_cursor_bounds_ = GetCursorBounds(FindCursorPosition(event.location()));
+  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 512 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);
 }
 
+gfx::Rect NativeTextfieldViews::GetCursorBounds(size_t cursor_pos) const {
+  string16 text = model_->GetVisibleText();
+  const gfx::Font& font = GetFont();
+  int x = font.GetStringWidth(text.substr(0U, cursor_pos));
+  DCHECK(x >= 0);

[oshima, 2011/06/07 17:32:52]

can you change to DCHECK_GE?

[msw, 2011/06/08 23:50:29]

Done.

+  int h = std::min(height() - GetInsets().height(), font.GetHeight());
+  gfx::Rect bounds(x, (height() - h) / 2, 0, h);
+  if (text.length() != cursor_pos)
+    bounds.set_width(font.GetStringWidth(text.substr(0, cursor_pos + 1)) - x);
+  return bounds;
+}
+
+
 void NativeTextfieldViews::UpdateCursorBoundsAndTextOffset() {
   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(model_->cursor_pos());
 
   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 26 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.
-    canvas->DrawRectInt(kCursorColor,
-                        cursor_bounds_.x(),
-                        cursor_bounds_.y(),
-                        insert_ ? 0 : cursor_bounds_.width(),
-                        cursor_bounds_.height());
+  if (textfield_->IsEnabled()) {
+    // Paint cursor. Replace cursor is drawn as rectangle for now.
+    if (is_cursor_visible_ && !model_->HasSelection())
+      canvas->DrawRectInt(kCursorColor,
+                          cursor_bounds_.x(),
+                          cursor_bounds_.y(),
+                          insert_ ? 0 : cursor_bounds_.width(),
+                          cursor_bounds_.height());
+    // Paint drop cursor.
+    if (is_drop_cursor_visible_)
+      canvas->DrawRectInt(kCursorColor,
+                          drop_cursor_bounds_.x(),
+                          drop_cursor_bounds_.y(),
+                          0,
+                          drop_cursor_bounds_.height());

[oshima, 2011/06/07 17:32:52]

basic question. Can both be visible at the same time?
I'm guessing that regular cursor isn't visible while
dragging so we dont need another bounds, no?

[msw, 2011/06/08 23:50:29]

Done.

   }
 }
 
 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 228 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