Add support for rect-based event targeting in views

ui/views/view.h

 // 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.
 
 #ifndef UI_VIEWS_VIEW_H_
 #define UI_VIEWS_VIEW_H_
 
 #include <algorithm>
 #include <map>
 #include <set>
@@ skipping 430 matching lines @@
 
   // Convert a point from the coordinate system of one View to another.
   //
   // |source| and |target| must be in the same widget, but doesn't need to be in
   // the same view hierarchy.
   // |source| can be NULL in which case it means the screen coordinate system.
   static void ConvertPointToTarget(const View* source,
                                    const View* target,
                                    gfx::Point* point);
 
+  // Convert |rect| from the coordinate system of |source| to the coordinate
+  // system of |target|.
+  //
+  // |source| and |target| must be in the same widget, but doesn't need to be in
+  // the same view hierarchy.
+  // |source| can be NULL in which case it means the screen coordinate system.
+  static void ConvertRectToTarget(const View* source,
+                                  const View* target,
+                                  gfx::Rect* rect);
+
   // Convert a point from a View's coordinate system to that of its Widget.
   static void ConvertPointToWidget(const View* src, gfx::Point* point);
 
   // Convert a point from the coordinate system of a View's Widget to that
   // View's coordinate system.
   static void ConvertPointFromWidget(const View* dest, gfx::Point* p);
 
   // Convert a point from a View's coordinate system to that of the screen.
   static void ConvertPointToScreen(const View* src, gfx::Point* point);
 
@@ skipping 80 matching lines @@
     flip_canvas_on_paint_for_rtl_ui_ = enable;
   }
 
   // Accelerated painting ------------------------------------------------------
 
   // Enable/Disable accelerated compositing.
   static void set_use_acceleration_when_possible(bool use);
   static bool get_use_acceleration_when_possible();
 
   // Input ---------------------------------------------------------------------
-  // The points (and mouse locations) in the following functions are in the
-  // view's coordinates, except for a RootView.
+  // The points, rects, mouse locations, and touch locations in the following
+  // functions are in the view's coordinates, except for a RootView.
 
-  // Returns the deepest visible descendant that contains the specified point
-  // and supports event handling.
-  virtual View* GetEventHandlerForPoint(const gfx::Point& point);
+  // Convenience functions which calls into GetEventHandler() with
+  // a 1x1 rect centered at |point|.
+  View* GetEventHandlerForPoint(const gfx::Point& point);
+
+  // If point-based targeting should be used, return the deepest visible
+  // descendant that contains the center point of |rect|.
+  // If rect-based targeting (i.e., fuzzing) should be used, return the
+  // closest visible descendant having at least kViewsFuzzingOverlap of
+  // its area covered by |rect|. If no such descendant exists, return the
+  // deepest visible descendant that contains the center point of |rect|.
+  virtual View* GetEventHandlerForRect(const gfx::Rect& rect);
 
   // Returns the deepest visible descendant that contains the specified point
   // and supports tooltips. If the view does not contain the point, returns
   // NULL.
   virtual View* GetTooltipHandlerForPoint(const gfx::Point& point);
 
   // Return the cursor that should be used for this view or the default cursor.
   // The event location is in the receiver's coordinate system. The caller is
   // responsible for managing the lifetime of the returned object, though that
   // lifetime may vary from platform to platform. On Windows and Aura,
@@ skipping 385 matching lines @@
   // to scroll. ScrollView interprets a return value of 0 (or negative)
   // to scroll by a default amount.
   //
   // See VariableRowHeightScrollHelper and FixedRowHeightScrollHelper for
   // implementations of common cases.
   virtual int GetPageScrollIncrement(ScrollView* scroll_view,
                                      bool is_horizontal, bool is_positive);
   virtual int GetLineScrollIncrement(ScrollView* scroll_view,
                                      bool is_horizontal, bool is_positive);
 
+  // Views fuzzing -------------------------------------------------------------
+  // Helper functions used by the views fuzzing algorithm.
+
+  // Returns true if |rect| is 1x1.
+  static bool UsePointBasedTargeting(const gfx::Rect& rect);
+
+  // Returns the percentage of |rect_1|'s area that is covered by |rect_2|.
+  static float PercentCoveredBy(const gfx::Rect& rect_1,
+                                const gfx::Rect& rect_2);
+
+  // Returns the square of the distance from |point| to the center line of
+  // |target_rect|. The center line of a rectangle is obtained by repeatedly
+  // stripping away 1px borders around the rectangle until a line remains.
+  static int DistanceSquaredFromCenterLineToPoint(const gfx::Point& point,
+                                                 const gfx::Rect& target_rect);
+
  protected:
   // Used to track a drag. RootView passes this into
   // ProcessMousePressed/Dragged.
   struct DragInfo {
     // Sets possible_drag to false and start_x/y to 0. This is invoked by
     // RootView prior to invoke ProcessMousePressed.
     void Reset();
 
     // Sets possible_drag to true and start_pt to the specified point.
     // This is invoked by the target view if it detects the press may generate
@@ skipping 335 matching lines @@
 
   // Coordinate conversion -----------------------------------------------------
 
   // Convert a point in the view's coordinate to an ancestor view's coordinate
   // system using necessary transformations. Returns whether the point was
   // successfully converted to the ancestor's coordinate system.
   bool ConvertPointForAncestor(const View* ancestor, gfx::Point* point) const;
 
   // Convert a point in the ancestor's coordinate system to the view's
   // coordinate system using necessary transformations. Returns whether the
-  // point was successfully from the ancestor's coordinate system to the view's
-  // coordinate system.
+  // point was successfully converted from the ancestor's coordinate system
+  // to the view's coordinate system.
   bool ConvertPointFromAncestor(const View* ancestor, gfx::Point* point) const;
 
+  // Convert a rect in the view's coordinate to an ancestor view's coordinate
+  // system using necessary transformations. Returns whether the rect was
+  // successfully converted to the ancestor's coordinate system.
+  bool ConvertRectForAncestor(const View* ancestor, gfx::Rect* rect) const;
+
+  // Convert a rect in the ancestor's coordinate system to the view's
+  // coordinate system using necessary transformations. Returns whether the
+  // rect was successfully converted from the ancestor's coordinate system
+  // to the view's coordinate system.
+  bool ConvertRectFromAncestor(const View* ancestor, gfx::Rect* rect) const;
+
   // Accelerated painting ------------------------------------------------------
 
   // Creates the layer and related fields for this view.
   void CreateLayer();
 
   // Parents all un-parented layers within this view's hierarchy to this view's
   // layer.
   void UpdateParentLayers();
 
   // Parents this view's layer to |parent_layer|, and sets its bounds and other
@@ skipping 208 matching lines @@
   // Belongs to this view, but it's reference-counted on some platforms
   // so we can't use a scoped_ptr. It's dereferenced in the destructor.
   NativeViewAccessibility* native_view_accessibility_;
 
   DISALLOW_COPY_AND_ASSIGN(View);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_VIEW_H_