Move views event targeting into ViewTargeterDelegate::TargetForRect()

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 11 matching lines @@
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/interpolated_transform.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/point_conversions.h"
-#include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/accessibility/native_view_accessibility.h"
 #include "ui/views/background.h"
 #include "ui/views/border.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/drag_controller.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/layout/layout_manager.h"
-#include "ui/views/rect_based_targeting_utils.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/native_widget_private.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_WIN)
 #include "base/win/scoped_gdi_object.h"
 #endif
 
 namespace {
 
 #if defined(OS_WIN)
 const bool kContextMenuOnMousePress = false;
 #else
 const bool kContextMenuOnMousePress = true;
 #endif
 
-// The minimum percentage of a view's area that needs to be covered by a rect
-// representing a touch region in order for that view to be considered by the
-// rect-based targeting algorithm.
-static const float kRectTargetOverlap = 0.6f;
-
 // Default horizontal drag threshold in pixels.
 // Same as what gtk uses.
 const int kDefaultHorizontalDragThreshold = 8;
 
 // Default vertical drag threshold in pixels.
 // Same as what gtk uses.
 const int kDefaultVerticalDragThreshold = 8;
 
 // Returns the top view in |view|'s hierarchy.
 const views::View* GetHierarchyRoot(const views::View* view) {
@@ skipping 764 matching lines @@
   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::GetEventHandlerForRect(const gfx::Rect& 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;
-
-  // |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);
-
-    if (!child->CanProcessEventsWithinSubtree())
-      continue;
-
-    // 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);
-    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);
-      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());
-      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());
-    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;
+  return GetEffectiveViewTargeter()->TargetForRect(this, rect);
 }
 
 bool View::CanProcessEventsWithinSubtree() const {
   return true;
 }
 
 View* View::GetTooltipHandlerForPoint(const gfx::Point& point) {
+  // TODO(tdanderson): Move this implementation into ViewTargetDelegate.
   if (!HitTestPoint(point) || !CanProcessEventsWithinSubtree())
     return NULL;
 
   // Walk the child Views recursively looking for the View that most
   // tightly encloses the specified point.
   for (int i = child_count() - 1; i >= 0; --i) {
     View* child = child_at(i);
     if (!child->visible())
       continue;
 
@@ skipping 15 matching lines @@
 #else
   return gfx::kNullCursor;
 #endif
 }
 
 bool View::HitTestPoint(const gfx::Point& point) const {
   return HitTestRect(gfx::Rect(point, gfx::Size(1, 1)));
 }
 
 bool View::HitTestRect(const gfx::Rect& rect) const {
-  ViewTargeter* view_targeter = targeter();
-  if (!view_targeter)
-    view_targeter = GetWidget()->GetRootView()->targeter();
-  CHECK(view_targeter);
-  return view_targeter->DoesIntersectRect(this, rect);
+  return GetEffectiveViewTargeter()->DoesIntersectRect(this, rect);
 }
 
 bool View::IsMouseHovered() {
   // If we haven't yet been placed in an onscreen view hierarchy, we can't be
   // hovered.
   if (!GetWidget())
     return false;
 
   // If mouse events are disabled, then the mouse cursor is invisible and
   // is therefore not hovering over this button.
@@ skipping 1362 matching lines @@
     if (HitTestPoint(location)) {
       ConvertPointToScreen(this, &location);
       ShowContextMenu(location, ui::MENU_SOURCE_MOUSE);
     }
   } else {
     OnMouseReleased(event);
   }
   // WARNING: we may have been deleted.
 }
 
+ViewTargeter* View::GetEffectiveViewTargeter() const {
+  ViewTargeter* view_targeter = targeter();
+  if (!view_targeter)
+    view_targeter = GetWidget()->GetRootView()->targeter();
+  CHECK(view_targeter);
+  return view_targeter;
+}
+
 // Accelerators ----------------------------------------------------------------
 
 void View::RegisterPendingAccelerators() {
   if (!accelerators_.get() ||
       registered_accelerator_count_ == accelerators_->size()) {
     // No accelerators are waiting for registration.
     return;
   }
 
   if (!GetWidget()) {
@@ skipping 129 matching lines @@
   // 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