aura: Repost click events that cause a menu to hide itself.

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"
 
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/rtl.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/controls/button/menu_button.h"
 #include "ui/views/controls/menu/menu_controller_delegate.h"
 #include "ui/views/controls/menu/menu_scroll_view_container.h"
 #include "ui/views/controls/menu/submenu_view.h"
 #include "ui/views/drag_utils.h"
 #include "ui/views/view_constants.h"
 #include "ui/views/views_delegate.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/client/dispatcher_client.h"
 #include "ui/aura/env.h"
+#include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #elif defined(TOOLKIT_USES_GTK)
 #include "ui/base/keycodes/keyboard_code_conversion_gtk.h"
 #endif
 
-using base::Time;
+#if defined(USE_AURA) && defined(USE_X11)
+#include <X11/Xlib.h>
+#endif
+
 using base::TimeDelta;
 using ui::OSExchangeData;
 
 // Period of the scroll timer (in milliseconds).
 static const int kScrollTimerMS = 30;
 
 // Delay, in ms, between when menus are selected are moused over and the menu
 // appears.
 static const int kShowDelay = 400;
 
@@ skipping 110 matching lines @@
     if (!part.is_scroll()) {
       StopScrolling();
       return;
     }
     DCHECK(part.submenu);
     SubmenuView* new_menu = part.submenu;
     bool new_is_up = (part.type == MenuController::MenuPart::SCROLL_UP);
     if (new_menu == submenu_ && is_scrolling_up_ == new_is_up)
       return;
 
-    start_scroll_time_ = Time::Now();
+    start_scroll_time_ = base::Time::Now();
     start_y_ = part.submenu->GetVisibleBounds().y();
     submenu_ = new_menu;
     is_scrolling_up_ = new_is_up;
 
     if (!scrolling_timer_.IsRunning()) {
       scrolling_timer_.Start(FROM_HERE,
                              TimeDelta::FromMilliseconds(kScrollTimerMS),
                              this, &MenuScrollTask::Run);
     }
   }
 
   void StopScrolling() {
     if (scrolling_timer_.IsRunning()) {
       scrolling_timer_.Stop();
       submenu_ = NULL;
     }
   }
 
   // The menu being scrolled. Returns null if not scrolling.
   SubmenuView* submenu() const { return submenu_; }
 
  private:
   void Run() {
     DCHECK(submenu_);
     gfx::Rect vis_rect = submenu_->GetVisibleBounds();
     const int delta_y = static_cast<int>(
-        (Time::Now() - start_scroll_time_).InMilliseconds() *
+        (base::Time::Now() - start_scroll_time_).InMilliseconds() *
         pixels_per_second_ / 1000);
     vis_rect.set_y(is_scrolling_up_ ?
         std::max(0, start_y_ - delta_y) :
         std::min(submenu_->height() - vis_rect.height(), start_y_ + delta_y));
     submenu_->ScrollRectToVisible(vis_rect);
   }
 
   // SubmenuView being scrolled.
   SubmenuView* submenu_;
 
   // Direction scrolling.
   bool is_scrolling_up_;
 
   // Timer to periodically scroll.
   base::RepeatingTimer<MenuScrollTask> scrolling_timer_;
 
   // Time we started scrolling at.
-  Time start_scroll_time_;
+  base::Time start_scroll_time_;
 
   // How many pixels to scroll per second.
   int pixels_per_second_;
 
   // Y-coordinate of submenu_view_ when scrolling started.
   int start_y_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuScrollTask);
 };
 
@@ skipping 556 matching lines @@
     return;  // Ignore presses on scroll buttons.
 
   if (part.type == MenuPart::NONE ||
       (part.type == MenuPart::MENU_ITEM && part.menu &&
        part.menu->GetRootMenuItem() != state_.item->GetRootMenuItem())) {
     // Mouse wasn't pressed over any menu, or the active menu, cancel.
 
     // 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.
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN) || defined(USE_AURA)
     RepostEvent(source, event);
     // NOTE: not reposting on linux seems fine.
 #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());
@@ skipping 1030 matching lines @@
   }
 
   // If no mnemonics found, look at first character of titles.
   details = FindChildForMnemonic(item, key, &TitleMatchesMnemonic);
   if (details.first_match != -1)
     return AcceptOrSelect(item, details);
 
   return false;
 }
 
-#if defined(OS_WIN) && !defined(USE_AURA)
+#if defined(OS_WIN)
 void MenuController::RepostEvent(SubmenuView* source,
                                  const LocatedEvent& event) {
   if (!state_.item) {
     // 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;
   }
 
@@ skipping 47 matching lines @@
       if (in_client_area) {
         PostMessage(window, event_type, event.native_event().wParam,
                     MAKELPARAM(window_x, window_y));
       } else {
         PostMessage(window, event_type, nc_hit_result,
                     MAKELPARAM(screen_loc.x(), screen_loc.y()));
       }
     }
   }
 }
-#endif  // defined(OS_WIN)
+#elif defined(USE_AURA)
+void MenuController::RepostEvent(SubmenuView* source,
+                                 const LocatedEvent& event) {
+  if (!state_.item) {
+    // 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;
+  }
+
+  // Release the capture.
+  SubmenuView* submenu = state_.item->GetRootMenuItem()->GetSubmenu();
+  submenu->ReleaseCapture();
+
+  gfx::Point screen_loc(event.location());
+  View::ConvertPointToScreen(source->GetScrollViewContainer(), &screen_loc);
+
+  XEvent xevent;
+  xevent.type = ButtonPress;
+  xevent.xbutton.x = screen_loc.x();
+  xevent.xbutton.y = screen_loc.y();
+  xevent.xbutton.state = 0;
+  xevent.xbutton.same_screen = True;
+  int flags = event.flags();
+  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
+    xevent.xbutton.button = 1;
+  else if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
+    xevent.xbutton.button = 2;
+  else if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
+    xevent.xbutton.button = 3;
+  else
+    return;
+
+  aura::RootWindow::GetInstance()->PostNativeEvent(&xevent);
+}
+#endif  // defined(USE_AURA)
 
 void MenuController::SetDropMenuItem(
     MenuItemView* new_target,
     MenuDelegate::DropPosition new_position) {
   if (new_target == drop_target_ && new_position == drop_position_)
     return;
 
   if (drop_target_) {
     drop_target_->GetParentMenuItem()->GetSubmenu()->SetDropMenuItem(
         NULL, MenuDelegate::DROP_NONE);
@@ skipping 126 matching lines @@
              (!pending_state_.item->HasSubmenu() ||
               !pending_state_.item->GetSubmenu()->IsShowing())) {
     // On exit if the user hasn't selected an item with a submenu, move the
     // selection back to the parent menu item.
     SetSelection(pending_state_.item->GetParentMenuItem(),
                  SELECTION_OPEN_SUBMENU);
   }
 }
 
 }  // namespace views