ui::LocatedEvent location() returns gfx::PointF

ui/views/controls/menu/menu_controller.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 "ui/views/controls/menu/menu_controller.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 369 matching lines @@
   // If we are shown on mouse press, we will eat the subsequent mouse down and
   // the parent widget will not be able to reset its state (it might have mouse
   // capture from the mouse down). So we clear its state here.
   if (parent) {
     View* root_view = parent->GetRootView();
     if (root_view) {
       root_view->SetMouseHandler(NULL);
       const ui::Event* event =
           static_cast<internal::RootView*>(root_view)->current_event();
       if (event && event->type() == ui::ET_MOUSE_PRESSED) {
-        gfx::Point screen_loc(
-            static_cast<const ui::MouseEvent*>(event)->location());
+        gfx::Point screen_loc(gfx::ToFlooredPoint(
+            static_cast<const ui::MouseEvent*>(event)->location()));
         View::ConvertPointToScreen(
             static_cast<View*>(event->target()), &screen_loc);
         menu_start_mouse_press_loc_ = screen_loc;
       }
     }
   }
 
   bool nested_menu = showing_;
   if (showing_) {
     // Only support nesting of blocking_run menus, nesting of
@@ skipping 151 matching lines @@
   }
 }
 
 void MenuController::OnMousePressed(SubmenuView* source,
                                     const ui::MouseEvent& event) {
   SetSelectionOnPointerDown(source, event);
 }
 
 void MenuController::OnMouseDragged(SubmenuView* source,
                                     const ui::MouseEvent& event) {
-  MenuPart part = GetMenuPart(source, event.location());
+  MenuPart part = GetMenuPart(source, gfx::ToFlooredPoint(event.location()));
   UpdateScrolling(part);
 
   if (!blocking_run_)
     return;
 
   if (possible_drag_) {
-    if (View::ExceededDragThreshold(event.location() - press_pt_))
+    if (View::ExceededDragThreshold(gfx::ToFlooredPoint(event.location()) -
+                                    press_pt_))
       StartDrag(source, press_pt_);
     return;
   }
   MenuItemView* mouse_menu = NULL;
   if (part.type == MenuPart::MENU_ITEM) {
     if (!part.menu)
       part.menu = source->GetMenuItem();
     else
       mouse_menu = part.menu;
     SetSelection(part.menu ? part.menu : state_.item, SELECTION_OPEN_SUBMENU);
   } else if (part.type == MenuPart::NONE) {
-    ShowSiblingMenu(source, event.location());
+    ShowSiblingMenu(source, gfx::ToFlooredPoint(event.location()));
   }
   UpdateActiveMouseView(source, event, mouse_menu);
 }
 
 void MenuController::OnMouseReleased(SubmenuView* source,
                                      const ui::MouseEvent& event) {
   if (!blocking_run_)
     return;
 
   DCHECK(state_.item);
   possible_drag_ = false;
   DCHECK(blocking_run_);
-  MenuPart part = GetMenuPart(source, event.location());
+  MenuPart part = GetMenuPart(source, gfx::ToFlooredPoint(event.location()));
   if (event.IsRightMouseButton() && part.type == MenuPart::MENU_ITEM) {
     MenuItemView* menu = part.menu;
     // |menu| is NULL means this event is from an empty menu or a separator.
     // If it is from an empty menu, use parent context menu instead of that.
     if (menu == NULL &&
         part.submenu->child_count() == 1 &&
         part.submenu->child_at(0)->id() == MenuItemView::kEmptyMenuItemViewID) {
       menu = part.parent;
     }
 
     if (menu != NULL && ShowContextMenu(menu, source, event,
                                         ui::MENU_SOURCE_MOUSE))
       return;
   }
 
   // We can use Ctrl+click or the middle mouse button to recursively open urls
   // for selected folder menu items. If it's only a left click, show the
   // contents of the folder.
   if (!part.is_scroll() && part.menu &&
       !(part.menu->HasSubmenu() &&
         (event.flags() & ui::EF_LEFT_MOUSE_BUTTON))) {
     if (GetActiveMouseView()) {
       SendMouseReleaseToActiveView(source, event);
       return;
     }
     // If a mouse release was received quickly after showing.
     base::TimeDelta time_shown = base::TimeTicks::Now() - menu_start_time_;
     if (time_shown.InMilliseconds() < menu_selection_hold_time_ms) {
       // And it wasn't far from the mouse press location.
-      gfx::Point screen_loc(event.location());
+      gfx::Point screen_loc(gfx::ToFlooredPoint(event.location()));
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
       gfx::Vector2d moved = screen_loc - menu_start_mouse_press_loc_;
       if (moved.Length() < kMaximumLengthMovedToActivate) {
         // Ignore the mouse release as it was likely this menu was shown under
         // the mouse and the action was just a normal click.
         return;
       }
     }
     if (part.menu->GetDelegate()->ShouldExecuteCommandWithoutClosingMenu(
             part.menu->GetCommand(), event)) {
@@ skipping 13 matching lines @@
   } else if (part.type == MenuPart::MENU_ITEM) {
     // User either clicked on empty space, or a menu that has children.
     SetSelection(part.menu ? part.menu : state_.item,
                  SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
   }
   SendMouseCaptureLostToActiveView();
 }
 
 void MenuController::OnMouseMoved(SubmenuView* source,
                                   const ui::MouseEvent& event) {
-  HandleMouseLocation(source, event.location());
+  HandleMouseLocation(source, gfx::ToFlooredPoint(event.location()));
 }
 
 void MenuController::OnMouseEntered(SubmenuView* source,
                                     const ui::MouseEvent& event) {
   // MouseEntered is always followed by a mouse moved, so don't need to
   // do anything here.
 }
 
 bool MenuController::OnMouseWheel(SubmenuView* source,
                                   const ui::MouseWheelEvent& event) {
-  MenuPart part = GetMenuPart(source, event.location());
+  MenuPart part = GetMenuPart(source, gfx::ToFlooredPoint(event.location()));
   return part.submenu && part.submenu->OnMouseWheel(event);
 }
 
 void MenuController::OnGestureEvent(SubmenuView* source,
                                     ui::GestureEvent* event) {
-  MenuPart part = GetMenuPart(source, event->location());
+  MenuPart part = GetMenuPart(source, gfx::ToFlooredPoint(event->location()));
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     SetSelectionOnPointerDown(source, *event);
     event->StopPropagation();
   } else if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
     if (part.type == MenuPart::MENU_ITEM && part.menu) {
       if (ShowContextMenu(part.menu, source, *event, ui::MENU_SOURCE_TOUCH))
         event->StopPropagation();
     }
   } else if (event->type() == ui::ET_GESTURE_TAP) {
     if (!part.is_scroll() && part.menu &&
@@ skipping 49 matching lines @@
 
 void MenuController::OnDragEntered(SubmenuView* source,
                                    const ui::DropTargetEvent& event) {
   valid_drop_coordinates_ = false;
 }
 
 int MenuController::OnDragUpdated(SubmenuView* source,
                                   const ui::DropTargetEvent& event) {
   StopCancelAllTimer();
 
-  gfx::Point screen_loc(event.location());
+  gfx::Point screen_loc(gfx::ToFlooredPoint(event.location()));
   View::ConvertPointToScreen(source, &screen_loc);
   if (valid_drop_coordinates_ && screen_loc == drop_pt_)
     return last_drop_operation_;
   drop_pt_ = screen_loc;
   valid_drop_coordinates_ = true;
 
   MenuItemView* menu_item = GetMenuItemAt(source, event.x(), event.y());
   bool over_empty_menu = false;
   if (!menu_item) {
     // See if we're over an empty menu.
     menu_item = GetEmptyMenuItemAt(source, event.x(), event.y());
     if (menu_item)
       over_empty_menu = true;
   }
   MenuDelegate::DropPosition drop_position = MenuDelegate::DROP_NONE;
   int drop_operation = ui::DragDropTypes::DRAG_NONE;
   if (menu_item) {
-    gfx::Point menu_item_loc(event.location());
+    gfx::Point menu_item_loc(gfx::ToFlooredPoint(event.location()));
     View::ConvertPointToTarget(source, menu_item, &menu_item_loc);
     MenuItemView* query_menu_item;
     if (!over_empty_menu) {
       int menu_item_height = menu_item->height();
       if (menu_item->HasSubmenu() &&
           (menu_item_loc.y() > kDropBetweenPixels &&
            menu_item_loc.y() < (menu_item_height - kDropBetweenPixels))) {
         drop_position = MenuDelegate::DROP_ON;
       } else {
         drop_position = (menu_item_loc.y() < menu_item_height / 2) ?
@@ skipping 171 matching lines @@
   }
 }
 
 void MenuController::SetSelectionOnPointerDown(SubmenuView* source,
                                                const ui::LocatedEvent& event) {
   if (!blocking_run_)
     return;
 
   DCHECK(!GetActiveMouseView());
 
-  MenuPart part = GetMenuPart(source, event.location());
+  MenuPart part = GetMenuPart(source, gfx::ToFlooredPoint(event.location()));
   if (part.is_scroll())
     return;  // Ignore presses on scroll buttons.
 
   // When this menu is opened through a touch event, a simulated right-click
   // is sent before the menu appears.  Ignore it.
   if ((event.flags() & ui::EF_RIGHT_MOUSE_BUTTON) &&
       (event.flags() & ui::EF_FROM_TOUCH))
     return;
 
   if (part.type == MenuPart::NONE ||
@@ skipping 13 matching lines @@
     // We're going to close and we own the mouse capture. We need to repost the
     // mouse down, otherwise the window the user clicked on won't get the event.
     RepostEvent(source, event);
 #endif
 
     // And close.
     ExitType exit_type = EXIT_ALL;
     if (!menu_stack_.empty()) {
       // We're running nested menus. Only exit all if the mouse wasn't over one
       // of the menus from the last run.
-      gfx::Point screen_loc(event.location());
+      gfx::Point screen_loc(gfx::ToFlooredPoint(event.location()));
       View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
       MenuPart last_part = GetMenuPartByScreenCoordinateUsingMenu(
           menu_stack_.back().item, screen_loc);
       if (last_part.type != MenuPart::NONE)
         exit_type = EXIT_OUTERMOST;
     }
     Cancel(exit_type);
 
 #if defined(OS_CHROMEOS)
     // We're going to exit the menu and want to repost the event so that is
     // is handled normally after the context menu has exited. We call
     // RepostEvent after Cancel so that mouse capture has been released so
     // that finding the event target is unaffected by the current capture.
     RepostEvent(source, event);
 #endif
     // Do not repost events for Linux Aura because this behavior is more
     // consistent with the behavior of other Linux apps.
     return;
   }
 
   // On a press we immediately commit the selection, that way a submenu
   // pops up immediately rather than after a delay.
   int selection_types = SELECTION_UPDATE_IMMEDIATELY;
   if (!part.menu) {
     part.menu = part.parent;
     selection_types |= SELECTION_OPEN_SUBMENU;
   } else {
     if (part.menu->GetDelegate()->CanDrag(part.menu)) {
       possible_drag_ = true;
-      press_pt_ = event.location();
+      press_pt_ = gfx::ToFlooredPoint(event.location());
     }
     if (part.menu->HasSubmenu())
       selection_types |= SELECTION_OPEN_SUBMENU;
   }
   SetSelection(part.menu, selection_types);
 }
 
 void MenuController::StartDrag(SubmenuView* source,
                                const gfx::Point& location) {
   MenuItemView* item = state_.item;
@@ skipping 323 matching lines @@
 bool MenuController::ShowContextMenu(MenuItemView* menu_item,
                                      SubmenuView* source,
                                      const ui::LocatedEvent& event,
                                      ui::MenuSourceType source_type) {
   // Set the selection immediately, making sure the submenu is only open
   // if it already was.
   int selection_types = SELECTION_UPDATE_IMMEDIATELY;
   if (state_.item == pending_state_.item && state_.submenu_open)
     selection_types |= SELECTION_OPEN_SUBMENU;
   SetSelection(pending_state_.item, selection_types);
-  gfx::Point loc(event.location());
+  gfx::Point loc(gfx::ToFlooredPoint(event.location()));
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &loc);
 
   if (menu_item->GetDelegate()->ShowContextMenu(
           menu_item, menu_item->GetCommand(), loc, source_type)) {
     SendMouseCaptureLostToActiveView();
     return true;
   }
   return false;
 }
 
@@ skipping 780 matching lines @@
     // We some times get an event after closing all the menus. Ignore it. Make
     // sure the menu is in fact not visible. If the menu is visible, then
     // we're in a bad state where we think the menu isn't visibile but it is.
     DCHECK(!source->GetWidget()->IsVisible());
     return;
   }
 
   state_.item->GetRootMenuItem()->GetSubmenu()->ReleaseCapture();
 #endif
 
-  gfx::Point screen_loc(event.location());
+  gfx::Point screen_loc(gfx::ToFlooredPoint(event.location()));
   View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
   gfx::NativeView native_view = source->GetWidget()->GetNativeView();
   if (!native_view)
     return;
 
   gfx::Screen* screen = gfx::Screen::GetScreenFor(native_view);
   gfx::NativeWindow window = screen->GetWindowAtScreenPoint(screen_loc);
 
 #if defined(OS_WIN)
   // PostMessage() to metro windows isn't allowed (access will be denied). Don't
@@ skipping 96 matching lines @@
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 void MenuController::UpdateActiveMouseView(SubmenuView* event_source,
                                            const ui::MouseEvent& event,
                                            View* target_menu) {
   View* target = NULL;
-  gfx::Point target_menu_loc(event.location());
+  gfx::Point target_menu_loc(gfx::ToFlooredPoint(event.location()));
   if (target_menu && target_menu->has_children()) {
     // Locate the deepest child view to send events to.  This code assumes we
     // don't have to walk up the tree to find a view interested in events. This
     // is currently true for the cases we are embedding views, but if we embed
     // more complex hierarchies it'll need to change.
     View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                                &target_menu_loc);
     View::ConvertPointFromScreen(target_menu, &target_menu_loc);
     target = target_menu->GetEventHandlerForPoint(target_menu_loc);
     if (target == target_menu || !target->enabled())
@@ skipping 31 matching lines @@
     active_mouse_view->OnMouseDragged(mouse_dragged_event);
   }
 }
 
 void MenuController::SendMouseReleaseToActiveView(SubmenuView* event_source,
                                                   const ui::MouseEvent& event) {
   View* active_mouse_view = GetActiveMouseView();
   if (!active_mouse_view)
     return;
 
-  gfx::Point target_loc(event.location());
+  gfx::Point target_loc(gfx::ToFlooredPoint(event.location()));
   View::ConvertPointToScreen(event_source->GetScrollViewContainer(),
                              &target_loc);
   View::ConvertPointFromScreen(active_mouse_view, &target_loc);
   ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, target_loc, target_loc,
                                event.flags(), event.changed_button_flags());
   // Reset active mouse view before sending mouse released. That way if it calls
   // back to us, we aren't in a weird state.
   SetActiveMouseView(NULL);
   active_mouse_view->OnMouseReleased(release_event);
 }
@@ skipping 84 matching lines @@
   }
 }
 
 gfx::Screen* MenuController::GetScreen() {
   aura::Window* root = GetOwnerRootWindow(owner_);
   return root ? gfx::Screen::GetScreenFor(root)
               : gfx::Screen::GetNativeScreen();
 }
 
 }  // namespace views