Makes it so child views of menuitemview can be traversed with the

views/controls/menu/menu_controller.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/controls/menu/menu_controller.h"
 
 #include "app/l10n_util.h"
 #include "app/os_exchange_data.h"
 #include "base/i18n/rtl.h"
 #include "base/keyboard_codes.h"
@@ skipping 33 matching lines @@
 // Amount to inset submenus.
 static const int kSubmenuHorizontalInset = 3;
 
 namespace views {
 
 // Convenience for scrolling the view such that the origin is visible.
 static void ScrollToVisible(View* view) {
   view->ScrollRectToVisible(gfx::Rect(gfx::Point(), view->size()));
 }
 
+// Returns the first descendant of |view| that is hot tracked.
+static View* GetFirstHotTrackedView(View* view) {
+  if (!view)
+    return NULL;
+
+  if (view->IsHotTracked())
+    return view;
+
+  for (int i = 0; i < view->GetChildViewCount(); ++i) {
+    View* hot_view = GetFirstHotTrackedView(view->GetChildViewAt(i));
+    if (hot_view)
+      return hot_view;
+  }
+  return NULL;
+}
+
+// Recurses through the child views of |view| returning the first view starting
+// at |start| that is focusable. A value of -1 for |start| indicates to start at
+// the first view (if |forward| is false, iterating starts at the last view). If
+// |forward| is true the children are considered first to last, otherwise last
+// to first.
+static View* GetFirstFocusableView(View* view, int start, bool forward) {
+  if (forward) {
+    for (int i = start == -1 ? 0 : start; i < view->GetChildViewCount(); ++i) {
+      View* deepest = GetFirstFocusableView(view->GetChildViewAt(i), -1,
+                                            forward);

[Jay Civelli, 2010/06/09 16:03:47]

Nit: you could use true instead of forward.

+      if (deepest)
+        return deepest;
+    }
+  } else {
+    for (int i = start == -1 ? view->GetChildViewCount() - 1 : start;
+         i >= 0; --i) {
+      View* deepest = GetFirstFocusableView(view->GetChildViewAt(i), -1,
+                                            forward);

[Jay Civelli, 2010/06/09 16:03:47]

Nit: you could use false instead of forward.

+      if (deepest)
+        return deepest;
+    }
+  }
+  return view->IsFocusable() ? view : NULL;
+}
+
+// Returns the first child of |start| that is focusable.
+static View* GetInitialFocusableView(View* start, bool forward) {
+  return GetFirstFocusableView(start, -1, forward);
+}
+
+// Returns the next view after |start_at| that is focusable. Returns NULL if
+// there are no focusable children of |ancestor| after |start_at|.
+static View* GetNextFocusableView(View* ancestor,
+                                  View* start_at,
+                                  bool forward) {
+  DCHECK(ancestor->IsParentOf(start_at));
+  View* parent = start_at;
+  do {
+    View* new_parent = parent->GetParent();
+    int index = new_parent->GetChildIndex(parent);
+    index += forward ? 1 : -1;
+    if (forward || index != -1) {
+      View* next = GetFirstFocusableView(new_parent, index, forward);
+      if (next)
+        return next;
+    }
+    parent = new_parent;
+  } while (parent != ancestor);
+  return NULL;
+}
+
 // MenuScrollTask --------------------------------------------------------------
 
 // MenuScrollTask is used when the SubmenuView does not all fit on screen and
 // the mouse is over the scroll up/down buttons. MenuScrollTask schedules
 // itself with a RepeatingTimer. When Run is invoked MenuScrollTask scrolls
 // appropriately.
 
 class MenuController::MenuScrollTask {
  public:
   MenuScrollTask() : submenu_(NULL) {
@@ skipping 204 matching lines @@
                                   bool update_immediately) {
   size_t paths_differ_at = 0;
   std::vector<MenuItemView*> current_path;
   std::vector<MenuItemView*> new_path;
   BuildPathsAndCalculateDiff(pending_state_.item, menu_item, &current_path,
                              &new_path, &paths_differ_at);
 
   size_t current_size = current_path.size();
   size_t new_size = new_path.size();
 
+  if (pending_state_.item != menu_item && pending_state_.item) {
+    View* current_hot_view = GetFirstHotTrackedView(pending_state_.item);
+    if (current_hot_view)
+      current_hot_view->SetHotTracked(false);
+  }
+
   // Notify the old path it isn't selected.
   for (size_t i = paths_differ_at; i < current_size; ++i)
     current_path[i]->SetSelected(false);
 
   // Notify the new path it is selected.
   for (size_t i = paths_differ_at; i < new_size; ++i)
     new_path[i]->SetSelected(true);
 
   if (menu_item && menu_item->GetDelegate())
     menu_item->GetDelegate()->SelectionChanged(menu_item);
@@ skipping 470 matching lines @@
         OpenSubmenuChangeSelectionIfCan();
       break;
 
     case base::VKEY_LEFT:
       if (base::i18n::IsRTL())
         OpenSubmenuChangeSelectionIfCan();
       else
         CloseSubmenu();
       break;
 
+    case base::VKEY_SPACE:
+      SendAcceleratorToHotTrackedView();
+      break;
+
     case base::VKEY_RETURN:
       if (pending_state_.item) {
         if (pending_state_.item->HasSubmenu()) {
           OpenSubmenuChangeSelectionIfCan();
-        } else if (pending_state_.item->IsEnabled()) {
+        } else if (!SendAcceleratorToHotTrackedView() &&
+                   pending_state_.item->IsEnabled()) {
           Accept(pending_state_.item, 0);
           return false;
         }
       }
       break;
 
     case base::VKEY_ESCAPE:
       if (!state_.item->GetParentMenuItem() ||
           (!state_.item->GetParentMenuItem()->GetParentMenuItem() &&
            (!state_.item->HasSubmenu() ||
@@ skipping 43 matching lines @@
 MenuController::~MenuController() {
   DCHECK(!showing_);
   StopShowTimer();
   StopCancelAllTimer();
 #ifdef DEBUG_MENU
   instance_count--;
   DLOG(INFO) << "destroyed MC, count=" << instance_count;
 #endif
 }
 
+bool MenuController::SendAcceleratorToHotTrackedView() {
+  View* hot_view = GetFirstHotTrackedView(pending_state_.item);
+  if (!hot_view)
+    return false;
+
+  Accelerator accelerator(base::VKEY_RETURN, false, false, false);
+  hot_view->AcceleratorPressed(accelerator);
+  hot_view->SetHotTracked(true);
+  return true;
+}
+
 void MenuController::UpdateInitialLocation(
     const gfx::Rect& bounds,
     MenuItemView::AnchorPosition position) {
   pending_state_.initial_bounds = bounds;
   if (bounds.height() > 1) {
     // Inset the bounds slightly, otherwise drag coordinates don't line up
     // nicely and menus close prematurely.
     pending_state_.initial_bounds.Inset(0, 1);
   }
   pending_state_.anchor = position;
@@ skipping 82 matching lines @@
       CloseMenu(item);
       last_item = item;
       item = item->GetParentMenuItem();
     }
     i->submenu_open = false;
     i->item = last_item;
   }
 }
 
 MenuItemView* MenuController::GetMenuItemAt(View* source, int x, int y) {
+  // Walk the view hierarchy until we find a menu item (or the root).
   View* child_under_mouse = source->GetViewForPoint(gfx::Point(x, y));
+  while (child_under_mouse &&
+         child_under_mouse->GetID() != MenuItemView::kMenuItemViewID) {
+    child_under_mouse = child_under_mouse->GetParent();
+  }
   if (child_under_mouse && child_under_mouse->IsEnabled() &&
       child_under_mouse->GetID() == MenuItemView::kMenuItemViewID) {
     return static_cast<MenuItemView*>(child_under_mouse);
   }
   return NULL;
 }
 
 MenuItemView* MenuController::GetEmptyMenuItemAt(View* source, int x, int y) {
   View* child_under_mouse = source->GetViewForPoint(gfx::Point(x, y));
   if (child_under_mouse &&
@@ skipping 368 matching lines @@
 void MenuController::IncrementSelection(int delta) {
   MenuItemView* item = pending_state_.item;
   DCHECK(item);
   if (pending_state_.submenu_open && item->HasSubmenu() &&
       item->GetSubmenu()->IsShowing()) {
     // A menu is selected and open, but none of its children are selected,
     // select the first menu item.
     if (item->GetSubmenu()->GetMenuItemCount()) {
       SetSelection(item->GetSubmenu()->GetMenuItemAt(0), false, false);
       ScrollToVisible(item->GetSubmenu()->GetMenuItemAt(0));
-      return;  // return so else case can fall through.
+      return;
     }
   }
+
+  if (item->GetChildViewCount()) {
+    View* hot_view = GetFirstHotTrackedView(item);
+    if (hot_view) {
+      hot_view->SetHotTracked(false);
+      View* to_make_hot = GetNextFocusableView(item, hot_view, delta == 1);
+      if (to_make_hot) {
+        to_make_hot->SetHotTracked(true);
+        return;
+      }
+    } else {
+      View* to_make_hot = GetInitialFocusableView(item, delta == 1);
+      if (to_make_hot) {
+        to_make_hot->SetHotTracked(true);
+        return;
+      }
+    }
+  }
+
   if (item->GetParentMenuItem()) {
     MenuItemView* parent = item->GetParentMenuItem();
     int parent_count = parent->GetSubmenu()->GetMenuItemCount();
     if (parent_count > 1) {
       for (int i = 0; i < parent_count; ++i) {
         if (parent->GetSubmenu()->GetMenuItemAt(i) == item) {
           int next_index = (i + delta + parent_count) % parent_count;
           ScrollToVisible(parent->GetSubmenu()->GetMenuItemAt(next_index));
-          SetSelection(parent->GetSubmenu()->GetMenuItemAt(next_index), false,
-                       false);
+          MenuItemView* to_select =
+              parent->GetSubmenu()->GetMenuItemAt(next_index);
+          SetSelection(to_select, false, false);
+          View* to_make_hot = GetInitialFocusableView(to_select, delta == 1);
+          if (to_make_hot)
+            to_make_hot->SetHotTracked(true);
           break;
         }
       }
     }
   }
 }
 
 void MenuController::OpenSubmenuChangeSelectionIfCan() {
   MenuItemView* item = pending_state_.item;
   if (item->HasSubmenu()) {
@@ skipping 168 matching lines @@
   if (!scroll_task_.get())
     scroll_task_.reset(new MenuScrollTask());
   scroll_task_->Update(part);
 }
 
 void MenuController::StopScrolling() {
   scroll_task_.reset(NULL);
 }
 
 }  // namespace views