[Linux Views] Refactor accelerator handler related code.

views/widget/widget_gtk.cc

 // Copyright (c) 2010 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 "views/widget/widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 
@@ skipping 228 matching lines @@
       ignore_drag_leave_(false),
       opacity_(255),
       drag_data_(NULL),
       in_paint_now_(false),
       is_active_(false),
       transient_to_parent_(false),
       got_initial_focus_in_(false),
       has_focus_(false),
       delegate_(NULL),
       always_on_top_(false),
-      is_double_buffered_(false) {
+      is_double_buffered_(false),
+      should_handle_menu_key_release_(false) {
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
     MessageLoopForUI* loop = MessageLoopForUI::current();
     if (loop)
       loop->AddObserver(DropObserver::Get());
   }
 
   if (type_ != TYPE_CHILD)
     focus_manager_ = new FocusManager(this);
@@ skipping 279 matching lines @@
   g_signal_connect(widget_, "show",
                    G_CALLBACK(&OnShowThunk), this);
   g_signal_connect(widget_, "hide",
                    G_CALLBACK(&OnHideThunk), this);
 
   // Views/FocusManager (re)sets the focus to the root window,
   // so we need to connect signal handlers to the gtk window.
   // See views::Views::Focus and views::FocusManager::ClearNativeFocus
   // for more details.
   g_signal_connect(widget_, "key_press_event",
-                   G_CALLBACK(&OnKeyPressThunk), this);
+                   G_CALLBACK(&OnKeyEventThunk), this);
   g_signal_connect(widget_, "key_release_event",
-                   G_CALLBACK(&OnKeyReleaseThunk), this);
+                   G_CALLBACK(&OnKeyEventThunk), this);
 
   // Drag and drop.
   gtk_drag_dest_set(window_contents_, static_cast<GtkDestDefaults>(0),
                     NULL, 0, GDK_ACTION_COPY);
   g_signal_connect(window_contents_, "drag_motion",
                    G_CALLBACK(&OnDragMotionThunk), this);
   g_signal_connect(window_contents_, "drag_data_received",
                    G_CALLBACK(&OnDragDataReceivedThunk), this);
   g_signal_connect(window_contents_, "drag_drop",
                    G_CALLBACK(&OnDragDropThunk), this);
@@ skipping 292 matching lines @@
 
 void WidgetGtk::ClearNativeFocus() {
   DCHECK(type_ != TYPE_CHILD);
   if (!GetNativeView()) {
     NOTREACHED();
     return;
   }
   gtk_window_set_focus(GTK_WINDOW(GetNativeView()), NULL);
 }
 
+bool WidgetGtk::HandleKeyboardEvent(GdkEventKey* event) {
+  if (!focus_manager_)
+    return false;
+
+  KeyEvent key(event);
+  int key_code = key.GetKeyCode();
+  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 unhandled VKEY_MENU key press event.
+  if (key_code != base::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+    should_handle_menu_key_release_ = false;
+
+  if (event->type == GDK_KEY_PRESS) {
+    // VKEY_MENU is triggered by key release event.
+    if (key_code != base::VKEY_MENU)
+      handled = focus_manager_->OnKeyEvent(key);
+    else
+      should_handle_menu_key_release_ = true;
+  } else if (key_code == base::VKEY_MENU && should_handle_menu_key_release_ &&
+             (key.GetFlags() & ~Event::EF_ALT_DOWN) == 0) {
+    // trigger VKEY_MENU when only this key is pressed and released, and both

[Jay Civelli, 2010/08/04 18:21:00]

Nit: Trigger

+    // press and release events are not handled by others.
+    Accelerator accelerator(base::VKEY_MENU, false, false, false);
+    handled = focus_manager_->ProcessAccelerator(accelerator);
+  }
+
+  return handled;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // WidgetGtk, protected:
 
 // static
 int WidgetGtk::GetFlagsForEventButton(const GdkEventButton& event) {
   int flags = Event::GetFlagsFromGdkState(event.state);
   switch (event.button) {
     case 1:
       flags |= Event::EF_LEFT_BUTTON_DOWN;
       break;
@@ skipping 207 matching lines @@
 
 gboolean WidgetGtk::OnScroll(GtkWidget* widget, GdkEventScroll* event) {
   return ProcessScroll(event);
 }
 
 gboolean WidgetGtk::OnFocusIn(GtkWidget* 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;
+
   if (type_ == TYPE_CHILD)
     return false;
 
   // See description of got_initial_focus_in_ for details on this.
   if (!got_initial_focus_in_) {
     got_initial_focus_in_ = true;
     SetInitialFocus();
   } else {
     focus_manager_->RestoreFocusedView();
   }
   return false;
 }
 
 gboolean WidgetGtk::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 (type_ == TYPE_CHILD)
     return false;
 
   // The top-level window lost focus, store the focused view.
   focus_manager_->StoreFocusedView();
   return false;
 }
 
-gboolean WidgetGtk::OnKeyPress(GtkWidget* widget, GdkEventKey* event) {
-  KeyEvent key_event(event);
-  return root_view_->ProcessKeyEvent(key_event);
-}
+gboolean WidgetGtk::OnKeyEvent(GtkWidget* widget, GdkEventKey* event) {
+  KeyEvent key(event);
 
-gboolean WidgetGtk::OnKeyRelease(GtkWidget* widget, GdkEventKey* event) {
-  KeyEvent key_event(event);
-  return root_view_->ProcessKeyEvent(key_event);
+  // 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.GetKeyCode() != base::VKEY_MENU || event->type != GDK_KEY_RELEASE)
+    should_handle_menu_key_release_ = false;
+
+  bool handled = false;
+
+  // Dispatch the key event to View hierarchy first.
+  handled = root_view_->ProcessKeyEvent(key);
+
+  // 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
+  // here.
+  if (!handled && GTK_IS_WINDOW(widget))
+    handled = gtk_window_propagate_key_event(GTK_WINDOW(widget), event);
+
+  // On Linux, in order to handle VKEY_MENU (Alt) accelerator key correctly and
+  // avoid issues like: http://crbug.com/40966 and http://crbug.com/49701, we
+  // should only send the key event to the focus manager if it's not handled by
+  // any View or native GtkWidget.
+  // The flow is different when the focus is in a RenderWidgetHostViewGtk, which
+  // always consumes the key event and send it back to us later by calling
+  // HandleKeyboardEvent() directly, if it's not handled by webkit.
+  if (!handled)
+    handled = HandleKeyboardEvent(event);
+
+  // Always return true for toplevel window to prevents GtkWindow's default key
+  // event handler.
+  return GTK_IS_WINDOW(widget) ? true : handled;
 }
 
 gboolean WidgetGtk::OnQueryTooltip(GtkWidget* widget,
                                    gint x,
                                    gint y,
                                    gboolean keyboard_mode,
                                    GtkTooltip* tooltip) {
   return tooltip_manager_->ShowTooltip(x, y, keyboard_mode, tooltip);
 }
 
@@ skipping 413 matching lines @@
     GtkWindow* window = GTK_WINDOW(element->data);
     DCHECK(window);
     RootView *root_view = FindRootView(window);
     if (root_view)
       root_view->NotifyLocaleChanged();
   }
   g_list_free(window_list);
 }
 
 }  // namespace views