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

views/controls/menu/menu_item_view.h

 // 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.
 
 #ifndef VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #define VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "views/view.h"
 
 namespace views {
 
 class MenuButton;
 class MenuController;
 class MenuDelegate;
 class SubmenuView;
 
 // MenuItemView --------------------------------------------------------------
 
 // MenuItemView represents a single menu item with a label and optional icon.
 // Each MenuItemView may also contain a submenu, which in turn may contain
 // any number of child MenuItemViews.
 //
 // To use a menu create an initial MenuItemView using the constructor that
 // takes a MenuDelegate, then create any number of child menu items by way
 // of the various AddXXX methods.
 //
 // MenuItemView is itself a View, which means you can add Views to each
-// MenuItemView. This normally NOT want you want, rather add other child Views
-// to the submenu of the MenuItemView.
+// MenuItemView. This is normally NOT want you want, rather add other child
+// Views to the submenu of the MenuItemView. Any child views of the MenuItemView
+// that are focusable can be navigated to by way of the up/down arrow and can be
+// activated by way of space/return keys. Activating a focusable child results
+// in |AcceleratorPressed| being invoked. Note, that as menus try not to steal
+// focus from the hosting window child views do not actually get focus. Instead
+// |SetHotTracked| is used as the user navigates around.
 //
 // There are two ways to show a MenuItemView:
 // 1. Use RunMenuAt. This blocks the caller, executing the selected command
 //    on success.
 // 2. Use RunMenuForDropAt. This is intended for use during a drop session
 //    and does NOT block the caller. Instead the delegate is notified when the
 //    menu closes via the DropMenuClosed method.
 
 class MenuItemView : public View {
  public:
@@ skipping 61 matching lines @@
   // item_id    The id of the item, used to identify it in delegate callbacks
   //            or (if delegate is NULL) to identify the command associated
   //            with this item with the controller specified in the ctor. Note
   //            that this value should not be 0 as this has a special meaning
   //            ("NULL command, no item selected")
   // label      The text label shown.
   // type       The type of item.
   void AppendMenuItem(int item_id,
                       const std::wstring& label,
                       Type type) {
-    AppendMenuItemInternal(item_id, label, SkBitmap(), type);
+    AppendMenuItemImpl(item_id, label, SkBitmap(), type);
   }
 
   // Append a submenu to this menu.
   // The returned pointer is owned by this menu.
   MenuItemView* AppendSubMenu(int item_id,
                               const std::wstring& label) {
-    return AppendMenuItemInternal(item_id, label, SkBitmap(), SUBMENU);
+    return AppendMenuItemImpl(item_id, label, SkBitmap(), SUBMENU);
   }
 
   // Append a submenu with an icon to this menu.
   // The returned pointer is owned by this menu.
   MenuItemView* AppendSubMenuWithIcon(int item_id,
                                       const std::wstring& label,
                                       const SkBitmap& icon) {
-    return AppendMenuItemInternal(item_id, label, icon, SUBMENU);
+    return AppendMenuItemImpl(item_id, label, icon, SUBMENU);
   }
 
   // This is a convenience for standard text label menu items where the label
   // is provided with this call.
   void AppendMenuItemWithLabel(int item_id,
                                const std::wstring& label) {
     AppendMenuItem(item_id, label, NORMAL);
   }
 
   // This is a convenience for text label menu items where the label is
   // provided by the delegate.
   void AppendDelegateMenuItem(int item_id) {
     AppendMenuItem(item_id, std::wstring(), NORMAL);
   }
 
   // Adds a separator to this menu
   void AppendSeparator() {
-    AppendMenuItemInternal(0, std::wstring(), SkBitmap(), SEPARATOR);
+    AppendMenuItemImpl(0, std::wstring(), SkBitmap(), SEPARATOR);
   }
 
   // Appends a menu item with an icon. This is for the menu item which
   // needs an icon. Calling this function forces the Menu class to draw
   // the menu, instead of relying on Windows.
   void AppendMenuItemWithIcon(int item_id,
                               const std::wstring& label,
                               const SkBitmap& icon) {
-    AppendMenuItemInternal(item_id, label, icon, NORMAL);
+    AppendMenuItemImpl(item_id, label, icon, NORMAL);
   }
 
+  // All the AppendXXX methods funnel into this.
+  MenuItemView* AppendMenuItemImpl(int item_id,
+                                   const std::wstring& label,
+                                   const SkBitmap& icon,
+                                   Type type);
+
   // Returns the view that contains child menu items. If the submenu has
   // not been creates, this creates it.
   virtual SubmenuView* CreateSubmenu();
 
   // Returns true if this menu item has a submenu.
   virtual bool HasSubmenu() const { return (submenu_ != NULL); }
 
   // Returns the view containing child menu items.
   virtual SubmenuView* GetSubmenu() const { return submenu_; }
 
@@ skipping 58 matching lines @@
     has_icons_ = has_icons;
   }
 
   // Returns the descendant with the specified command.
   MenuItemView* GetMenuItemByID(int id);
 
   // Invoke if you remove/add children to the menu while it's showing. This
   // recalculates the bounds.
   void ChildrenChanged();
 
+  // Sizes any child views.
+  virtual void Layout();
+
  protected:
   // Creates a MenuItemView. This is used by the various AddXXX methods.
   MenuItemView(MenuItemView* parent, int command, Type type);
 
  private:
   // Calculates all sizes that we can from the OS.
   //
   // This is invoked prior to Running a menu.
   static void UpdateMenuPartSizes(bool has_icons);
 
   // Called by the two constructors to initialize this menu item.
   void Init(MenuItemView* parent,
             int command,
             MenuItemView::Type type,
             MenuDelegate* delegate);
 
-  // All the AddXXX methods funnel into this.
-  MenuItemView* AppendMenuItemInternal(int item_id,
-                                       const std::wstring& label,
-                                       const SkBitmap& icon,
-                                       Type type);
-
   // Invoked by the MenuController when the menu closes as the result of
   // drag and drop run.
   void DropMenuClosed(bool notify_delegate);
 
   // The RunXXX methods call into this to set up the necessary state before
   // running.
   void PrepareForRun(bool has_mnemonics);
 
   // Returns the flags passed to DrawStringInt.
   int GetDrawStringFlags();
@@ skipping 15 matching lines @@
   void Paint(gfx::Canvas* canvas, bool for_drag);
 
   // Destroys the window used to display this menu and recursively destroys
   // the windows used to display all descendants.
   void DestroyAllMenuHosts();
 
   // Returns the various margins.
   int GetTopMargin();
   int GetBottomMargin();
 
+  // Returns the preferred width (and padding) of any children.
+  int GetChildPreferredWidth();
+
   // The delegate. This is only valid for the root menu item. You shouldn't
   // use this directly, instead use GetDelegate() which walks the tree as
   // as necessary.
   MenuDelegate* delegate_;
 
   // Returns the controller for the run operation, or NULL if the menu isn't
   // showing.
   MenuController* controller_;
 
   // Used to detect when Cancel was invoked.
@@ skipping 37 matching lines @@
 
   // Preferred height of menu items. Reset every time a menu is run.
   static int pref_menu_height_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuItemView);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_