[rough WIP] Make View::GetEventHandlerForRect() non-virtual

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 10 matching lines @@
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/compositor/compositor.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/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/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 750 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) {
+  // Terry - make a helper for this logic
+  ViewTargeter* view_targeter = targeter();
+  if (!view_targeter)
+    view_targeter = GetWidget()->GetRootView()->targeter();
+  CHECK(view_targeter);
+  return view_targeter->TargetForRect(this, 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.
@@ skipping 51 matching lines @@
   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;
+  */
 }
 
 bool View::CanProcessEventsWithinSubtree() const {
   return true;
 }
 
 View* View::GetTooltipHandlerForPoint(const gfx::Point& point) {
   if (!HitTestPoint(point) || !CanProcessEventsWithinSubtree())
     return NULL;
 
@@ skipping 22 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 {
-  // If no ViewTargeter is installed on |this|, use the ViewTargeter installed
-  // on our root view instead.
   ViewTargeter* view_targeter = targeter();
   if (!view_targeter)
     view_targeter = GetWidget()->GetRootView()->targeter();
   CHECK(view_targeter);
-
-  // TODO(tdanderson): The check for !HasHitTestMask() is temporary. Remove
-  //                   the check along with the duplicated code below once all
-  //                   of the masked views subclass MaskedViewDelegate.
-  //                   HasHitTestMask() and GetHitTestMaskDeprecated() can also
-  //                   be removed from the View interface at that time.
-  if (!HasHitTestMask())
-    return view_targeter->DoesIntersectRect(this, rect);
-
-  if (GetLocalBounds().Intersects(rect)) {
-    gfx::Path mask;
-    HitTestSource source = HIT_TEST_SOURCE_MOUSE;
-    if (!views::UsePointBasedTargeting(rect))
-      source = HIT_TEST_SOURCE_TOUCH;
-    GetHitTestMaskDeprecated(source, &mask);
-    SkRegion clip_region;
-    clip_region.setRect(0, 0, width(), height());
-    SkRegion mask_region;
-    return mask_region.setPath(mask, clip_region) &&
-           mask_region.intersects(RectToSkIRect(rect));
-  }
-  // Outside our bounds.
-  return false;
+  return view_targeter->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 595 matching lines @@
     // the front.
     for (Views::reverse_iterator it(children_.rbegin());
          it != children_.rend(); ++it) {
       (*it)->ReorderChildLayers(parent_layer);
     }
   }
 }
 
 // Input -----------------------------------------------------------------------
 
-bool View::HasHitTestMask() const {
-  return false;
-}
-
-void View::GetHitTestMaskDeprecated(HitTestSource source,
-                                    gfx::Path* mask) const {
-  DCHECK(mask);
-}
-
 View::DragInfo* View::GetDragInfo() {
   return parent_ ? parent_->GetDragInfo() : NULL;
 }
 
 // Focus -----------------------------------------------------------------------
 
 void View::OnFocus() {
   // TODO(beng): Investigate whether it's possible for us to move this to
   //             Focus().
   // By default, we clear the native focus. This ensures that no visible native
@@ skipping 892 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