views: Update event-related API to use PointF/RectF instead of Point/Rect.

ui/views/view.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 800 matching lines @@
   return widget ? widget->GetThemeProvider() : NULL;
 }
 
 const ui::NativeTheme* View::GetNativeTheme() const {
   const Widget* widget = GetWidget();
   return widget ? widget->GetNativeTheme() : ui::NativeTheme::instance();
 }
 
 // Input -----------------------------------------------------------------------
 
-View* View::GetEventHandlerForPoint(const gfx::Point& point) {
-  return GetEventHandlerForRect(gfx::Rect(point, gfx::Size(1, 1)));
+View* View::GetEventHandlerForPoint(const gfx::PointF& point) {
+  return GetEventHandlerForRect(gfx::RectF(point, gfx::Size(1, 1)));
 }
 
-View* View::GetEventHandlerForRect(const gfx::Rect& rect) {
+View* View::GetEventHandlerForRect(const gfx::RectF& rect) {
   // |rect_view| represents the current best candidate to return
   // if rect-based targeting (i.e., fuzzing) is used.
   // |rect_view_distance| is used to keep track of the distance
   // between the center point of |rect_view| and the center
   // point of |rect|.
   View* rect_view = NULL;
-  int rect_view_distance = INT_MAX;
+  float rect_view_distance = std::numeric_limits<float>::max();
 
   // |point_view| represents the view that would have been returned
   // from this function call if point-based targeting were used.
   View* point_view = NULL;
 
   for (int i = child_count() - 1; i >= 0; --i) {
     View* child = child_at(i);
 
     // Ignore any children which are invisible or do not intersect |rect|.
     if (!child->visible())
       continue;
-    gfx::RectF rect_in_child_coords_f(rect);
-    ConvertRectToTarget(this, child, &rect_in_child_coords_f);
-    gfx::Rect rect_in_child_coords = gfx::ToEnclosingRect(
-        rect_in_child_coords_f);
+    gfx::RectF rect_in_child_coords(rect);
+    ConvertRectToTarget(this, child, &rect_in_child_coords);
     if (!child->HitTestRect(rect_in_child_coords))
       continue;
 
     View* cur_view = child->GetEventHandlerForRect(rect_in_child_coords);
 
     if (views::UsePointBasedTargeting(rect))
       return cur_view;
 
     gfx::RectF cur_view_bounds_f(cur_view->GetLocalBounds());
     ConvertRectToTarget(cur_view, this, &cur_view_bounds_f);
     gfx::Rect cur_view_bounds = gfx::ToEnclosingRect(
         cur_view_bounds_f);
     if (views::PercentCoveredBy(cur_view_bounds, rect) >= kRectTargetOverlap) {
       // |cur_view| is a suitable candidate for rect-based targeting.
       // Check to see if it is the closest suitable candidate so far.
-      gfx::Point touch_center(rect.CenterPoint());
-      int cur_dist = views::DistanceSquaredFromCenterToPoint(touch_center,
-                                                             cur_view_bounds);
+      gfx::PointF touch_center(rect.CenterPoint());
+      float cur_dist = views::DistanceSquaredFromCenterToPoint(touch_center,
+                                                               cur_view_bounds);
       if (!rect_view || cur_dist < rect_view_distance) {
         rect_view = cur_view;
         rect_view_distance = cur_dist;
       }
     } else if (!rect_view && !point_view) {
       // Rect-based targeting has not yielded any candidates so far. Check
       // if point-based targeting would have selected |cur_view|.
-      gfx::Point point_in_child_coords(rect_in_child_coords.CenterPoint());
+      gfx::PointF point_in_child_coords(rect_in_child_coords.CenterPoint());
       if (child->HitTestPoint(point_in_child_coords))
         point_view = child->GetEventHandlerForPoint(point_in_child_coords);
     }
   }
 
   if (views::UsePointBasedTargeting(rect) || (!rect_view && !point_view))
     return this;
 
   // If |this| is a suitable candidate for rect-based targeting, check to
   // see if it is closer than the current best suitable candidate so far.
   gfx::Rect local_bounds(GetLocalBounds());
   if (views::PercentCoveredBy(local_bounds, rect) >= kRectTargetOverlap) {
-    gfx::Point touch_center(rect.CenterPoint());
+    gfx::PointF touch_center(rect.CenterPoint());
     int cur_dist = views::DistanceSquaredFromCenterToPoint(touch_center,
                                                            local_bounds);
     if (!rect_view || cur_dist < rect_view_distance)
       rect_view = this;
   }
 
   return rect_view ? rect_view : point_view;
 }
 
 View* View::GetTooltipHandlerForPoint(const gfx::Point& point) {
@@ skipping 20 matching lines @@
 #if defined(OS_WIN)
   static ui::Cursor arrow;
   if (!arrow.platform())
     arrow.SetPlatformCursor(LoadCursor(NULL, IDC_ARROW));
   return arrow;
 #else
   return gfx::kNullCursor;
 #endif
 }
 
-bool View::HitTestPoint(const gfx::Point& point) const {
-  return HitTestRect(gfx::Rect(point, gfx::Size(1, 1)));
+bool View::HitTestPoint(const gfx::PointF& point) const {
+  return HitTestRect(gfx::RectF(point, gfx::Size(1, 1)));
 }
 
-bool View::HitTestRect(const gfx::Rect& rect) const {
-  if (GetLocalBounds().Intersects(rect)) {
+bool View::HitTestRect(const gfx::RectF& rect) const {
+  gfx::RectF local_bounds(GetLocalBounds());
+  if (local_bounds.Intersects(rect)) {
     if (HasHitTestMask()) {
       gfx::Path mask;
       HitTestSource source = HIT_TEST_SOURCE_MOUSE;
       if (!views::UsePointBasedTargeting(rect))
         source = HIT_TEST_SOURCE_TOUCH;
       GetHitTestMask(source, &mask);
       SkRegion clip_region;
       clip_region.setRect(0, 0, width(), height());
       SkRegion mask_region;
       return mask_region.setPath(mask, clip_region) &&
@@ skipping 342 matching lines @@
 }
 
 int View::OnPerformDrop(const ui::DropTargetEvent& event) {
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 void View::OnDragDone() {
 }
 
 // static
-bool View::ExceededDragThreshold(const gfx::Vector2d& delta) {
-  return (abs(delta.x()) > GetHorizontalDragThreshold() ||
-          abs(delta.y()) > GetVerticalDragThreshold());
+bool View::ExceededDragThreshold(const gfx::Vector2dF& delta) {
+  return (fabs(delta.x()) > GetHorizontalDragThreshold() ||
+          fabs(delta.y()) > GetVerticalDragThreshold());
 }
 
 // Accessibility----------------------------------------------------------------
 
 gfx::NativeViewAccessible View::GetNativeViewAccessible() {
   if (!native_view_accessibility_)
     native_view_accessibility_ = NativeViewAccessibility::Create(this);
   if (native_view_accessibility_)
     return native_view_accessibility_->GetNativeObject();
   return NULL;
@@ skipping 297 matching lines @@
 gfx::Point View::GetKeyboardContextMenuLocation() {
   gfx::Rect vis_bounds = GetVisibleBounds();
   gfx::Point screen_point(vis_bounds.x() + vis_bounds.width() / 2,
                           vis_bounds.y() + vis_bounds.height() / 2);
   ConvertPointToScreen(this, &screen_point);
   return screen_point;
 }
 
 // Drag and drop ---------------------------------------------------------------
 
-int View::GetDragOperations(const gfx::Point& press_pt) {
+int View::GetDragOperations(const gfx::PointF& press_pt) {
   return drag_controller_ ?
       drag_controller_->GetDragOperationsForView(this, press_pt) :
       ui::DragDropTypes::DRAG_NONE;
 }
 
-void View::WriteDragData(const gfx::Point& press_pt, OSExchangeData* data) {
+void View::WriteDragData(const gfx::PointF& press_pt, OSExchangeData* data) {
   DCHECK(drag_controller_);
   drag_controller_->WriteDragDataForView(this, press_pt, data);
 }
 
 bool View::InDrag() {
   Widget* widget = GetWidget();
   return widget ? widget->dragged_view() == this : false;
 }
 
 int View::GetHorizontalDragThreshold() {
@@ skipping 116 matching lines @@
 
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // View, private:
 
 // DropInfo --------------------------------------------------------------------
 
 void View::DragInfo::Reset() {
   possible_drag = false;
-  start_pt = gfx::Point();
+  start_pt = gfx::PointF();
 }
 
-void View::DragInfo::PossibleDrag(const gfx::Point& p) {
+void View::DragInfo::PossibleDrag(const gfx::PointF& p) {
   possible_drag = true;
   start_pt = p;
 }
 
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaintBoundsChanged(SchedulePaintType type) {
   // If we have a layer and the View's size did not change, we do not need to
   // schedule any paints since the layer will be redrawn at its new location
   // during the next Draw() cycle in the compositor.
@@ skipping 588 matching lines @@
   // TODO(beng): The TooltipManager NULL check can be removed when we
   //             consolidate Init() methods and make views_unittests Init() all
   //             Widgets that it uses.
   if (widget && widget->GetTooltipManager())
     widget->GetTooltipManager()->UpdateTooltip();
 }
 
 // Drag and drop ---------------------------------------------------------------
 
 bool View::DoDrag(const ui::LocatedEvent& event,
-                  const gfx::Point& press_pt,
+                  const gfx::PointF& press_pt,
                   ui::DragDropTypes::DragEventSource source) {
   int drag_operations = GetDragOperations(press_pt);
   if (drag_operations == ui::DragDropTypes::DRAG_NONE)
     return false;
 
   Widget* widget = GetWidget();
   // We should only start a drag from an event, implying we have a widget.
   DCHECK(widget);
 
   // Don't attempt to start a drag while in the process of dragging. This is
   // especially important on X where we can get multiple mouse move events when
   // we start the drag.
   if (widget->dragged_view())
     return false;
 
   OSExchangeData data;
   WriteDragData(press_pt, &data);
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views