Add support for rect-based event targeting in views

chrome/browser/ui/views/tabs/tab_strip.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 "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 236 matching lines @@
   virtual void AnimationCanceled(const ui::Animation* animation) OVERRIDE {
     tab_->set_dragging(false);
   }
 
  private:
   Tab* tab_;
 
   DISALLOW_COPY_AND_ASSIGN(ResetDraggingStateDelegate);
 };
 
-// If |dest| contains the point |point_in_source| the event handler from |dest|
+// If |dest| intersects the rect |rect_in_source| the event handler from |dest|
 // is returned. Otherwise NULL is returned.
-views::View* ConvertPointToViewAndGetEventHandler(
+views::View* ConvertRectToViewAndGetEventHandler(
     views::View* source,
     views::View* dest,
-    const gfx::Point& point_in_source) {
-  gfx::Point dest_point(point_in_source);
-  views::View::ConvertPointToTarget(source, dest, &dest_point);
-  return dest->HitTestPoint(dest_point) ?
-      dest->GetEventHandlerForPoint(dest_point) : NULL;
+    const gfx::Rect& rect_in_source) {
+  gfx::Rect dest_rect(rect_in_source);
+  views::View::ConvertRectToTarget(source, dest, &dest_rect);
+  return dest->HitTestRect(dest_rect) ?
+      dest->GetEventHandlerForRect(dest_rect) : NULL;
 }
 
 // Gets a tooltip handler for |point_in_source| from |dest|. Note that |dest|
 // should return NULL if it does not contain the point.
 views::View* ConvertPointToViewAndGetTooltipHandler(
     views::View* source,
     views::View* dest,
     const gfx::Point& point_in_source) {
   gfx::Point dest_point(point_in_source);
   views::View::ConvertPointToTarget(source, dest, &dest_point);
@@ skipping 623 matching lines @@
 
 bool TabStrip::IsTabStripCloseable() const {
   return !IsDragSessionActive();
 }
 
 void TabStrip::UpdateLoadingAnimations() {
   controller_->UpdateLoadingAnimations();
 }
 
 bool TabStrip::IsPositionInWindowCaption(const gfx::Point& point) {
-  views::View* v = GetEventHandlerForPoint(point);
+  return IsRectInWindowCaption(gfx::Rect(point, gfx::Size(1, 1)));
+}
+
+bool TabStrip::IsRectInWindowCaption(const gfx::Rect& rect) {
+  views::View* v = GetEventHandlerForRect(rect);
 
   // If there is no control at this location, claim the hit was in the title
   // bar to get a move action.
   if (v == this)
     return true;
 
-  // Check to see if the point is within the non-button parts of the new tab
+  // Check to see if the rect intersects the non-button parts of the new tab
   // button. The button has a non-rectangular shape, so if it's not in the
   // visual portions of the button we treat it as a click to the caption.
-  gfx::Point point_in_newtab_coords(point);
-  View::ConvertPointToTarget(this, newtab_button_, &point_in_newtab_coords);
-  if (newtab_button_->GetLocalBounds().Contains(point_in_newtab_coords) &&
-      !newtab_button_->HitTestPoint(point_in_newtab_coords)) {
+  gfx::Rect rect_in_newtab_coords(rect);
+  View::ConvertRectToTarget(this, newtab_button_, &rect_in_newtab_coords);
+  if (newtab_button_->GetLocalBounds().Intersects(rect_in_newtab_coords) &&
+      !newtab_button_->HitTestRect(rect_in_newtab_coords))
     return true;
-  }
 
   // All other regions, including the new Tab button, should be considered part
   // of the containing Window's client area so that regular events can be
   // processed for them.
   return false;
 }
 
 void TabStrip::SetBackgroundOffset(const gfx::Point& offset) {
   for (int i = 0; i < tab_count(); ++i)
     tab_at(i)->set_background_offset(offset);
@@ skipping 485 matching lines @@
 
   controller()->PerformDrop(drop_before, drop_index, url);
 
   return GetDropEffect(event);
 }
 
 void TabStrip::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_PAGETABLIST;
 }
 
-views::View* TabStrip::GetEventHandlerForPoint(const gfx::Point& point) {
+views::View* TabStrip::GetEventHandlerForRect(const gfx::Rect& rect) {
+  if (!View::UsePointBasedTargeting(rect))
+    return View::GetEventHandlerForRect(rect);
+
   if (!touch_layout_.get()) {
     // Return any view that isn't a Tab or this TabStrip immediately. We don't
     // want to interfere.
-    views::View* v = View::GetEventHandlerForPoint(point);
+    views::View* v = View::GetEventHandlerForRect(rect);
     if (v && v != this && strcmp(v->GetClassName(), Tab::kViewClassName))
       return v;
 
-    views::View* tab = FindTabHitByPoint(point);
+    views::View* tab = FindTabHitByPoint(rect.CenterPoint());
     if (tab)
       return tab;
   } else {
     if (newtab_button_->visible()) {
       views::View* view =
-          ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
+          ConvertRectToViewAndGetEventHandler(this, newtab_button_, rect);
       if (view)
         return view;
     }
-    Tab* tab = FindTabForEvent(point);
+    Tab* tab = FindTabForEvent(rect.CenterPoint());
     if (tab)
-      return ConvertPointToViewAndGetEventHandler(this, tab, point);
+      return ConvertRectToViewAndGetEventHandler(this, tab, rect);
   }
   return this;
 }
 
 views::View* TabStrip::GetTooltipHandlerForPoint(const gfx::Point& point) {
   if (!HitTestPoint(point))
     return NULL;
 
   if (!touch_layout_.get()) {
     // Return any view that isn't a Tab or this TabStrip immediately. We don't
@@ skipping 1122 matching lines @@
       true);
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToTarget(this, tab, &point_in_tab_coords);
   return tab->HitTestPoint(point_in_tab_coords);
 }
 
+bool TabStrip::IsRectInTab(Tab* tab,
+                           const gfx::Rect& rect_in_tabstrip_coords) {
+  gfx::Rect rect_in_tab_coords(rect_in_tabstrip_coords);
+  View::ConvertRectToTarget(this, tab, &rect_in_tab_coords);
+  return tab->HitTestRect(rect_in_tab_coords);
+}
+
 int TabStrip::GetStartXForNormalTabs() const {
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == 0)
     return 0;
   return mini_tab_count * (Tab::GetMiniWidth() + tab_h_offset()) +
       kMiniToNonMiniGap;
 }
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point) {
   if (touch_layout_.get()) {
@@ skipping 118 matching lines @@
   if (!adjust_layout_)
     return false;
 
 #if !defined(OS_CHROMEOS)
   if (ui::GetDisplayLayout() != ui::LAYOUT_TOUCH)
     return false;
 #endif
 
   return true;
 }