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

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 541 matching lines @@
   void EnableCanvasFlippingForRTLUI(bool enable) {
     flip_canvas_on_paint_for_rtl_ui_ = enable;
   }
 
   // Input ---------------------------------------------------------------------
   // The points, rects, mouse locations, and touch locations in the following
   // functions are in the view's coordinates, except for a RootView.
 
   // Convenience functions which calls into GetEventHandler() with
   // a 1x1 rect centered at |point|.
-  View* GetEventHandlerForPoint(const gfx::Point& point);
+  View* GetEventHandlerForPoint(const gfx::PointF& 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 kRectTargetOverlap of
   // its area covered by |rect|. If no such descendant exists, return the
   // deepest visible descendant that contains the center point of |rect|.
   // See http://goo.gl/3Jp2BD for more information about rect-based targeting.
-  virtual View* GetEventHandlerForRect(const gfx::Rect& rect);
+  virtual View* GetEventHandlerForRect(const gfx::RectF& 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,
   // the cursor is a shared resource.
   virtual gfx::NativeCursor GetCursor(const ui::MouseEvent& event);
 
   // A convenience function which calls HitTestRect() with a rect of size
   // 1x1 and an origin of |point|.
-  bool HitTestPoint(const gfx::Point& point) const;
+  bool HitTestPoint(const gfx::PointF& point) const;
 
   // Tests whether |rect| intersects this view's bounds.
-  virtual bool HitTestRect(const gfx::Rect& rect) const;
+  virtual bool HitTestRect(const gfx::RectF& rect) const;
 
   // Returns true if the mouse cursor is over |view| and mouse events are
   // enabled.
   bool IsMouseHovered();
 
   // This method is invoked when the user clicks on this view.
   // The provided event is in the receiver's coordinate system.
   //
   // Return true if you processed the event and want to receive subsequent
   // MouseDraggged and MouseReleased events.  This also stops the event from
@@ skipping 316 matching lines @@
   // Invoked during a drag and drop session when OnDragUpdated returns a valid
   // operation and the user release the mouse.
   virtual int OnPerformDrop(const ui::DropTargetEvent& event);
 
   // Invoked from DoDrag after the drag completes. This implementation does
   // nothing, and is intended for subclasses to do cleanup.
   virtual void OnDragDone();
 
   // Returns true if the mouse was dragged enough to start a drag operation.
   // delta_x and y are the distance the mouse was dragged.
-  static bool ExceededDragThreshold(const gfx::Vector2d& delta);
+  static bool ExceededDragThreshold(const gfx::Vector2dF& delta);
 
   // Accessibility -------------------------------------------------------------
 
   // Modifies |state| to reflect the current accessible state of this view.
   virtual void GetAccessibleState(ui::AXViewState* state) { }
 
   // Returns an instance of the native accessibility interface for this view.
   virtual gfx::NativeViewAccessible GetNativeViewAccessible();
 
   // Notifies assistive technology that an accessibility event has
@@ skipping 43 matching lines @@
   // 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
     // a drag.
-    void PossibleDrag(const gfx::Point& p);
+    void PossibleDrag(const gfx::PointF& p);
 
     // Whether the press may generate a drag.
     bool possible_drag;
 
     // Coordinates of the mouse press.
-    gfx::Point start_pt;
+    gfx::PointF start_pt;
   };
 
   // Size and disposition ------------------------------------------------------
 
   // Override to be notified when the bounds of the view have changed.
   virtual void OnBoundsChanged(const gfx::Rect& previous_bounds);
 
   // Called when the preferred size of a child view changed.  This gives the
   // parent an opportunity to do a fresh layout if that makes sense.
   virtual void ChildPreferredSizeChanged(View* child) {}
@@ skipping 167 matching lines @@
   // This method is invoked when the context menu is shown by way of the
   // keyboard.
   virtual gfx::Point GetKeyboardContextMenuLocation();
 
   // Drag and drop -------------------------------------------------------------
 
   // These are cover methods that invoke the method of the same name on
   // the DragController. Subclasses may wish to override rather than install
   // a DragController.
   // See DragController for a description of these methods.
-  virtual int GetDragOperations(const gfx::Point& press_pt);
-  virtual void WriteDragData(const gfx::Point& press_pt, OSExchangeData* data);
+  virtual int GetDragOperations(const gfx::PointF& press_pt);
+  virtual void WriteDragData(const gfx::PointF& press_pt, OSExchangeData* data);
 
   // Returns whether we're in the middle of a drag session that was initiated
   // by us.
   bool InDrag();
 
   // Returns how much the mouse needs to move in one direction to start a
   // drag. These methods cache in a platform-appropriate way. These values are
   // used by the public static method ExceededDragThreshold().
   static int GetHorizontalDragThreshold();
   static int GetVerticalDragThreshold();
@@ skipping 214 matching lines @@
   void UpdateTooltip();
 
   // Drag and drop -------------------------------------------------------------
 
   // Starts a drag and drop operation originating from this view. This invokes
   // WriteDragData to write the data and GetDragOperations to determine the
   // supported drag operations. When done, OnDragDone is invoked. |press_pt| is
   // in the view's coordinate system.
   // Returns true if a drag was started.
   bool DoDrag(const ui::LocatedEvent& event,
-              const gfx::Point& press_pt,
+              const gfx::PointF& press_pt,
               ui::DragDropTypes::DragEventSource source);
 
   //////////////////////////////////////////////////////////////////////////////
 
   // Creation and lifetime -----------------------------------------------------
 
   // False if this View is owned by its parent - i.e. it will be deleted by its
   // parent during its parents destruction. False is the default.
   bool owned_by_client_;
 
@@ skipping 127 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_