ui::LocatedEvent location() returns gfx::PointF

ui/views/controls/textfield/textfield.cc

 // Copyright (c) 2012 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 "ui/views/controls/textfield/textfield.h"
 
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "grit/ui_strings.h"
@@ skipping 474 matching lines @@
   const gfx::Insets& insets = GetInsets();
   return gfx::Size(GetFontList().GetExpectedTextWidth(default_width_in_chars_) +
                    insets.width(), GetFontList().GetHeight() + insets.height());
 }
 
 const char* Textfield::GetClassName() const {
   return kViewClassName;
 }
 
 gfx::NativeCursor Textfield::GetCursor(const ui::MouseEvent& event) {
-  bool in_selection = GetRenderText()->IsPointInSelection(event.location());
+  bool in_selection = GetRenderText()->IsPointInSelection(
+      gfx::ToFlooredPoint(event.location()));
   bool drag_event = event.type() == ui::ET_MOUSE_DRAGGED;
   bool text_cursor = !initiating_drag_ && (drag_event || !in_selection);
   return text_cursor ? GetNativeIBeamCursor() : gfx::kNullCursor;
 }
 
 bool Textfield::OnMousePressed(const ui::MouseEvent& event) {
   TrackMouseClicks(event);
 
   if (!controller_ || !controller_->HandleMouseEvent(this, event)) {
     if (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) {
       RequestFocus();
       ShowImeIfNeeded();
     }
 
     if (event.IsOnlyLeftMouseButton()) {
       OnBeforeUserAction();
       initiating_drag_ = false;
       switch (aggregated_clicks_) {
         case 0:
-          if (GetRenderText()->IsPointInSelection(event.location()))
+          if (GetRenderText()->IsPointInSelection(
+                  gfx::ToFlooredPoint(event.location())))
             initiating_drag_ = true;
           else
-            MoveCursorTo(event.location(), event.IsShiftDown());
+            MoveCursorTo(gfx::ToFlooredPoint(event.location()),
+                         event.IsShiftDown());
           break;
         case 1:
-          model_->MoveCursorTo(event.location(), false);
+          model_->MoveCursorTo(gfx::ToFlooredPoint(event.location()), false);
           model_->SelectWord();
           UpdateAfterChange(false, true);
           double_click_word_ = GetRenderText()->selection();
           break;
         case 2:
           SelectAll(false);
           break;
         default:
           NOTREACHED();
       }
       OnAfterUserAction();
     }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
     if (event.IsOnlyMiddleMouseButton()) {
-      if (GetRenderText()->IsPointInSelection(event.location())) {
+      if (GetRenderText()->IsPointInSelection(
+              gfx::ToFlooredPoint(event.location()))) {
         OnBeforeUserAction();
         ClearSelection();
         ui::ScopedClipboardWriter(
             ui::Clipboard::GetForCurrentThread(),
             ui::CLIPBOARD_TYPE_SELECTION).WriteText(base::string16());
         OnAfterUserAction();
       } else if(!read_only()) {
         PasteSelectionClipboard(event);
       }
     }
 #endif
   }
 
   touch_selection_controller_.reset();
   return true;
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
   // Don't adjust the cursor on a potential drag and drop, or if the mouse
   // movement from the last mouse click does not exceed the drag threshold.
   if (initiating_drag_ || !event.IsOnlyLeftMouseButton() ||
-      !ExceededDragThreshold(event.location() - last_click_location_)) {
+      !ExceededDragThreshold(gfx::ToFlooredPoint(event.location()) -
+                             last_click_location_)) {
     return true;
   }
 
   OnBeforeUserAction();
-  model_->MoveCursorTo(event.location(), true);
+  model_->MoveCursorTo(gfx::ToFlooredPoint(event.location()), true);
   if (aggregated_clicks_ == 1) {
     model_->SelectWord();
     // Expand the selection so the initially selected word remains selected.
     gfx::Range selection = GetRenderText()->selection();
     const size_t min = std::min(selection.GetMin(),
                                 double_click_word_.GetMin());
     const size_t max = std::max(selection.GetMax(),
                                 double_click_word_.GetMax());
     const bool reversed = selection.is_reversed();
     selection.set_start(reversed ? max : min);
     selection.set_end(reversed ? min : max);
     model_->SelectRange(selection);
   }
   UpdateAfterChange(false, true);
   OnAfterUserAction();
   return true;
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   OnBeforeUserAction();
   // Cancel suspected drag initiations, the user was clicking in the selection.
   if (initiating_drag_)
-    MoveCursorTo(event.location(), false);
+    MoveCursorTo(gfx::ToFlooredPoint(event.location()), false);
   initiating_drag_ = false;
   UpdateSelectionClipboard();
   OnAfterUserAction();
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
   bool handled = controller_ && controller_->HandleKeyEvent(this, event);
   touch_selection_controller_.reset();
   if (handled)
     return true;
@@ skipping 31 matching lines @@
 
 void Textfield::OnGestureEvent(ui::GestureEvent* event) {
   switch (event->type()) {
     case ui::ET_GESTURE_TAP_DOWN:
       OnBeforeUserAction();
       RequestFocus();
       ShowImeIfNeeded();
 
       // We don't deselect if the point is in the selection
       // because TAP_DOWN may turn into a LONG_PRESS.
-      if (!GetRenderText()->IsPointInSelection(event->location()))
-        MoveCursorTo(event->location(), false);
+      if (!GetRenderText()->IsPointInSelection(
+              gfx::ToFlooredPoint(event->location())))
+        MoveCursorTo(gfx::ToFlooredPoint(event->location()), false);
       OnAfterUserAction();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       OnBeforeUserAction();
-      MoveCursorTo(event->location(), true);
+      MoveCursorTo(gfx::ToFlooredPoint(event->location()), true);
       OnAfterUserAction();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       CreateTouchSelectionControllerAndNotifyIt();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_TAP:
       if (event->details().tap_count() == 1) {
@@ skipping 10 matching lines @@
 #endif
       break;
     case ui::ET_GESTURE_LONG_PRESS:
       // If long press happens outside selection, select word and show context
       // menu (If touch selection is enabled, context menu is shown by the
       // |touch_selection_controller_|, hence we mark the event handled.
       // Otherwise, the regular context menu will be shown by views).
       // If long press happens in selected text and touch drag drop is enabled,
       // we will turn off touch selection (if one exists) and let views do drag
       // drop.
-      if (!GetRenderText()->IsPointInSelection(event->location())) {
+      if (!GetRenderText()->IsPointInSelection(
+              gfx::ToFlooredPoint(event->location()))) {
         OnBeforeUserAction();
         model_->SelectWord();
         touch_selection_controller_.reset(
             ui::TouchSelectionController::create(this));
         UpdateAfterChange(false, true);
         OnAfterUserAction();
         if (touch_selection_controller_)
           event->SetHandled();
       } else if (switches::IsTouchDragDropEnabled()) {
         initiating_drag_ = true;
@@ skipping 60 matching lines @@
   std::set<OSExchangeData::CustomFormat> custom_formats;
   GetDropFormats(&formats, &custom_formats);
   return enabled() && !read_only() &&
       data.HasAnyFormat(formats, custom_formats);
 }
 
 int Textfield::OnDragUpdated(const ui::DropTargetEvent& event) {
   DCHECK(CanDrop(event.data()));
   gfx::RenderText* render_text = GetRenderText();
   const gfx::Range& selection = render_text->selection();
-  drop_cursor_position_ = render_text->FindCursorPosition(event.location());
+  drop_cursor_position_ =
+      render_text->FindCursorPosition(gfx::ToFlooredPoint(event.location()));
   bool in_selection = !selection.is_empty() &&
       selection.Contains(gfx::Range(drop_cursor_position_.caret_pos()));
   drop_cursor_visible_ = !in_selection;
   // TODO(msw): Pan over text when the user drags to the visible text edge.
   OnCaretBoundsChanged();
   SchedulePaint();
 
   if (initiating_drag_) {
     if (in_selection)
       return ui::DragDropTypes::DRAG_NONE;
@@ skipping 12 matching lines @@
   DCHECK(CanDrop(event.data()));
   drop_cursor_visible_ = false;
 
   if (controller_) {
     int drag_operation = controller_->OnDrop(event.data());
     if (drag_operation != ui::DragDropTypes::DRAG_NONE)
       return drag_operation;
   }
 
   gfx::RenderText* render_text = GetRenderText();
-  DCHECK(!initiating_drag_ ||
-         !render_text->IsPointInSelection(event.location()));
+  DCHECK(
+      !initiating_drag_ ||
+      !render_text->IsPointInSelection(gfx::ToFlooredPoint(event.location())));
   OnBeforeUserAction();
   skip_input_method_cancel_composition_ = true;
 
   gfx::SelectionModel drop_destination_model =
-      render_text->FindCursorPosition(event.location());
+      render_text->FindCursorPosition(gfx::ToFlooredPoint(event.location()));
   base::string16 new_text;
   event.data().GetString(&new_text);
 
   // Delete the current selection for a drag and drop within this view.
   const bool move = initiating_drag_ && !event.IsControlDown() &&
                     event.source_operations() & ui::DragDropTypes::DRAG_MOVE;
   if (move) {
     // Adjust the drop destination if it is on or after the current selection.
     size_t pos = drop_destination_model.caret_pos();
     pos -= render_text->selection().Intersect(gfx::Range(0, pos)).length();
@@ skipping 795 matching lines @@
     if (controller_)
       controller_->UpdateContextMenu(context_menu_contents_.get());
   }
   context_menu_runner_.reset(new MenuRunner(context_menu_contents_.get()));
 }
 
 void Textfield::TrackMouseClicks(const ui::MouseEvent& event) {
   if (event.IsOnlyLeftMouseButton()) {
     base::TimeDelta time_delta = event.time_stamp() - last_click_time_;
     if (time_delta.InMilliseconds() <= GetDoubleClickInterval() &&
-        !ExceededDragThreshold(event.location() - last_click_location_)) {
+        !ExceededDragThreshold(gfx::ToFlooredPoint(event.location()) -
+                               last_click_location_)) {
       // Upon clicking after a triple click, the count should go back to double
       // click and alternate between double and triple. This assignment maps
       // 0 to 1, 1 to 2, 2 to 1.
       aggregated_clicks_ = (aggregated_clicks_ % 2) + 1;
     } else {
       aggregated_clicks_ = 0;
     }
     last_click_time_ = event.time_stamp();
-    last_click_location_ = event.location();
+    last_click_location_ = gfx::ToFlooredPoint(event.location());
   }
 }
 
 bool Textfield::ImeEditingAllowed() const {
   // Disallow input method editing of password fields.
   ui::TextInputType t = GetTextInputType();
   return (t != ui::TEXT_INPUT_TYPE_NONE && t != ui::TEXT_INPUT_TYPE_PASSWORD);
 }
 
 void Textfield::RevealPasswordChar(int index) {
@@ skipping 29 matching lines @@
 }
 
 void Textfield::PasteSelectionClipboard(const ui::MouseEvent& event) {
   DCHECK(event.IsOnlyMiddleMouseButton());
   DCHECK(!read_only());
   base::string16 selection_clipboard_text = GetSelectionClipboardText();
   if (!selection_clipboard_text.empty()) {
     OnBeforeUserAction();
     gfx::Range range = GetSelectionModel().selection();
     gfx::LogicalCursorDirection affinity = GetSelectionModel().caret_affinity();
-    const gfx::SelectionModel mouse =
-        GetRenderText()->FindCursorPosition(event.location());
+    const gfx::SelectionModel mouse = GetRenderText()->FindCursorPosition(
+        gfx::ToFlooredPoint(event.location()));
     model_->MoveCursorTo(mouse);
     model_->InsertText(selection_clipboard_text);
     // Update the new selection range as needed.
     if (range.GetMin() >= mouse.caret_pos()) {
       const size_t length = selection_clipboard_text.length();
       range = gfx::Range(range.start() + length, range.end() + length);
     }
     model_->MoveCursorTo(gfx::SelectionModel(range, affinity));
     UpdateAfterChange(true, true);
     OnAfterUserAction();
   }
 }
 
 }  // namespace views