AURA/X11: Handle VKEY_MENU accelerator on content area

ui/views/widget/native_widget_gtk.cc

 // Copyright (c) 2011 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/widget/native_widget_gtk.h"
 
 #include <X11/Xatom.h>
 #include <X11/Xlib.h>
 #include <X11/extensions/shape.h>
 #include <gdk/gdk.h>
@@ skipping 340 matching lines @@
       ignore_drag_leave_(false),
       opacity_(255),
       drag_data_(NULL),
       window_state_(GDK_WINDOW_STATE_WITHDRAWN),
       is_active_(false),
       transient_to_parent_(false),
       got_initial_focus_in_(false),
       has_focus_(false),
       always_on_top_(false),
       is_double_buffered_(false),
-      should_handle_menu_key_release_(false),
       dragged_view_(NULL),
       painted_(false),
       has_pointer_grab_(false),
       has_keyboard_grab_(false),
       grab_notify_signal_id_(0),
       is_menu_(false),
       signal_registrar_(new ui::GtkSignalRegistrar) {
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
@@ skipping 184 matching lines @@
     GetWidget()->GetRootView()->SchedulePaint();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetGtk implementation:
 
 bool NativeWidgetGtk::HandleKeyboardEvent(const KeyEvent& key) {
   if (!GetWidget()->GetFocusManager())
     return false;
-
-  const int key_code = key.key_code();
-  bool handled = false;
-
-  // Always reset |should_handle_menu_key_release_| unless we are handling a
-  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
-  // be activated when handling a VKEY_MENU key release event which is preceded
-  // by an un-handled VKEY_MENU key press event.
-  if (key_code != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
-    should_handle_menu_key_release_ = false;
-
-  if (key.type() == ui::ET_KEY_PRESSED) {
-    // VKEY_MENU is triggered by key release event.
-    // FocusManager::OnKeyEvent() returns false when the key has been consumed.
-    if (key_code != ui::VKEY_MENU)
-      handled = !GetWidget()->GetFocusManager()->OnKeyEvent(key);
-    else
-      should_handle_menu_key_release_ = true;
-  } else if (key_code == ui::VKEY_MENU && should_handle_menu_key_release_ &&
-             (key.flags() & ~ui::EF_ALT_DOWN) == 0) {
-    // Trigger VKEY_MENU when only this key is pressed and released, and both
-    // press and release events are not handled by others.
-    ui::Accelerator accelerator(ui::VKEY_MENU, false, false, false);
-    handled = GetWidget()->GetFocusManager()->ProcessAccelerator(accelerator);
-  }
-
-  return handled;
+  return GetWidget()->GetFocusManager()->OnKeyEvent(key);
 }
 
 bool NativeWidgetGtk::SuppressFreezeUpdates() {
   if (!painted_) {
     painted_ = true;
     return true;
   }
   return false;
 }
 
@@ skipping 993 matching lines @@
     delegate_->OnMouseEvent(mouse_event);
   }
   return true;
 }
 
 gboolean NativeWidgetGtk::OnScroll(GtkWidget* widget, GdkEventScroll* event) {
   MouseWheelEvent mouse_event(TransformEvent(event));
   return delegate_->OnMouseEvent(mouse_event);
 }
 
-gboolean NativeWidgetGtk::OnFocusIn(GtkWidget* widget, GdkEventFocus* event) {
+gboolean NativeWidgetGtk::OnFocusIn(GtkWidget* gtk_widget,
+                                    GdkEventFocus* event) {
   if (has_focus_)
     return false;  // This is the second focus-in event in a row, ignore it.
   has_focus_ = true;
 
-  should_handle_menu_key_release_ = false;
+  Widget* widget = GetWidget();
 
-  if (!GetWidget()->is_top_level())
+  if (widget->GetFocusManager())
+    widget->GetFocusManager()->ResetMenuKeyState();
+
+  if (!widget->is_top_level())
     return false;
 
   // Only top-level Widget should have an InputMethod instance.
-  InputMethod* input_method = GetWidget()->GetInputMethod();
+  InputMethod* input_method = widget->GetInputMethod();
   if (input_method)
     input_method->OnFocus();
 
   // See description of got_initial_focus_in_ for details on this.
   if (!got_initial_focus_in_) {
     got_initial_focus_in_ = true;
     // Sets initial focus here. On X11/Gtk, window creation
     // is asynchronous and a focus request has to be made after a window
     // gets created.
-    GetWidget()->SetInitialFocus();
+    widget->SetInitialFocus();
   }
   return false;
 }
 
 gboolean NativeWidgetGtk::OnFocusOut(GtkWidget* widget, GdkEventFocus* event) {
   if (!has_focus_)
     return false;  // This is the second focus-out event in a row, ignore it.
   has_focus_ = false;
 
   if (!GetWidget()->is_top_level())
@@ skipping 124 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetGtk, private:
 
 void NativeWidgetGtk::ScheduleDraw() {
   SchedulePaintInRect(gfx::Rect(gfx::Point(), size_));
 }
 
 void NativeWidgetGtk::DispatchKeyEventPostIME(const KeyEvent& key) {
-  // Always reset |should_handle_menu_key_release_| unless we are handling a
-  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
-  // be activated when handling a VKEY_MENU key release event which is preceded
-  // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
-  if (key.key_code() != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
-    should_handle_menu_key_release_ = false;
+  if (GetWidget()->GetFocusManager())
+    GetWidget()->GetFocusManager()->MaybeResetMenuKeyState(key);
 
   // Send the key event to View hierarchy first.
   bool handled = delegate_->OnKeyEvent(key);
 
   if (key.key_code() == ui::VKEY_PROCESSKEY || handled)
     return;
 
   // Dispatch the key event to native GtkWidget hierarchy.
   // To prevent GtkWindow from handling the key event as a keybinding, we need
   // to bypass GtkWindow's default key event handler and dispatch the event
@@ skipping 433 matching lines @@
     button_pressed = event->type == GDK_BUTTON_PRESS ||
         event->type == GDK_2BUTTON_PRESS ||
         event->type == GDK_3BUTTON_PRESS;
     gdk_event_free(event);
   }
   return button_pressed;
 }
 
 }  // namespace internal
 }  // namespace views