[cros] Network dropdown button in WebUI.

views/controls/menu/menu_item_view.h

 // 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.
 
 #ifndef VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #define VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 22 matching lines @@
 
 namespace views {
 
 class MenuButton;
 class MenuController;
 class MenuDelegate;
 class SubmenuView;
 
 struct MenuConfig;
 
+// MenuItemInterface -----------------------------------------------------------
+
+// Interface class for the menu items.
+class MenuItemInterface {
+ public:

[rhashimoto, 2011/07/29 17:17:13]

virtual destructor?

[Nikita (slow), 2011/08/05 23:40:26]

Obsolete, using ui::MenuModel now.

+  // Append a sub-menu to this menu.
+  // The returned pointer is owned by this menu.
+  virtual MenuItemInterface* AppendSubMenu(int item_id,
+                              const std::wstring& label) = 0;

[rhashimoto, 2011/07/29 17:17:13]

nit: wrapped indentation needs to be adjusted in this class

[Nikita (slow), 2011/08/05 23:40:26]

Obsolete, using ui::MenuModel now.

+
+  // Append a sub-menu with an icon to this menu.
+  // The returned pointer is owned by this menu.
+  virtual MenuItemInterface* AppendSubMenuWithIcon(int item_id,
+                                      const std::wstring& label,
+                                      const SkBitmap& icon) = 0;
+
+  // This is a convenience for standard text label menu items where the label
+  // is provided with this call.
+  virtual MenuItemInterface* AppendMenuItemWithLabel(int item_id,
+                               const std::wstring& label) = 0;
+
+
+  // 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.
+  virtual MenuItemInterface* AppendMenuItemWithIcon(int item_id,
+                              const std::wstring& label,
+                              const SkBitmap& icon) = 0;
+
+  // Adds a separator to this menu
+  virtual void AppendSeparator() = 0;
+
+  // Clears the sub-menu.
+  virtual void ClearSubmenu() = 0;
+
+  // Called when update is done.
+  virtual void ChildrenChanged() = 0;
+
+  // Hides and cancels the menu. This does nothing if the menu is not open.
+  virtual void Cancel() = 0;
+
+  virtual void set_margins(int top_margin, int bottom_margin) = 0;
+};
+
 // 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 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 VIEWS_API MenuItemView : public View {
+class VIEWS_API MenuItemView : public MenuItemInterface, public View {
  public:
   friend class MenuController;
 
   // The menu item view's class name.
   static const char kViewClassName[];
 
   // ID used to identify menu items.
   static const int kMenuItemViewID;
 
   // ID used to identify empty menu items.
@@ skipping 58 matching lines @@
   void RunMenuAt(Widget* parent,
                  MenuButton* button,
                  const gfx::Rect& bounds,
                  AnchorPosition anchor,
                  bool has_mnemonics);
   void RunMenuForDropAt(Widget* parent,
                         const gfx::Rect& bounds,
                         AnchorPosition anchor);
 
   // Hides and cancels the menu. This does nothing if the menu is not open.
-  void Cancel();
+  virtual void Cancel();

[rhashimoto, 2011/07/29 17:17:13]

group overridden methods, add OVERRIDE

[Nikita (slow), 2011/08/05 23:40:26]

Obsolete, using ui::MenuModel now.

 
   // Add an item to the menu at a specified index.  ChildrenChanged() should
   // called after adding menu items if the menu may be active.
   MenuItemView* AddMenuItemAt(int index,
                               int item_id,
                               const std::wstring& label,
                               const SkBitmap& icon,
                               Type type);
 
   // Remove an item from the menu at a specified index.
@@ skipping 10 matching lines @@
   // label      The text label shown.
   // type       The type of item.
   MenuItemView* AppendMenuItem(int item_id,
                       const std::wstring& label,
                       Type type) {
     return 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,
+  virtual MenuItemInterface* AppendSubMenu(int item_id,
                               const std::wstring& label) {
     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,
+  virtual MenuItemInterface* AppendSubMenuWithIcon(int item_id,
                                       const std::wstring& label,
                                       const SkBitmap& icon) {
     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.
-  MenuItemView* AppendMenuItemWithLabel(int item_id,
+  virtual MenuItemInterface* AppendMenuItemWithLabel(int item_id,
                                const std::wstring& label) {
     return AppendMenuItem(item_id, label, NORMAL);
   }
 
   // This is a convenience for text label menu items where the label is
   // provided by the delegate.
   MenuItemView* AppendDelegateMenuItem(int item_id) {
     return AppendMenuItem(item_id, std::wstring(), NORMAL);
   }
 
   // Adds a separator to this menu
-  void AppendSeparator() {
+  virtual void AppendSeparator() {
     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.
-  MenuItemView* AppendMenuItemWithIcon(int item_id,
+  virtual MenuItemInterface* AppendMenuItemWithIcon(int item_id,
                               const std::wstring& label,
                               const SkBitmap& icon) {
     return AppendMenuItemImpl(item_id, label, icon, NORMAL);
   }
 
   // Creates a menu item for the specified entry in the model and appends it as
   // a child. |index| should be offset by GetFirstItemIndex() before calling
   // this function.
   MenuItemView* AppendMenuItemFromModel(ui::MenuModel* model,
                                         int index,
                                         int id);
 
   // 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;
 
+  virtual void ClearSubmenu();
+
   // Returns the view containing child menu items.
   virtual SubmenuView* GetSubmenu() const;
 
   // Returns the parent menu item.
   MenuItemView* GetParentMenuItem() const { return parent_menu_item_; }
 
   // Sets the title
   void SetTitle(const std::wstring& title);
 
   // Returns the title.
@@ skipping 51 matching lines @@
   // makes the menus slightly wider and taller.
   void set_has_icons(bool has_icons) {
     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();
+  virtual void ChildrenChanged();
 
   // Sizes any child views.
   virtual void Layout();
 
   // Returns the amount of space needed to accomodate the accelerator. The
   // space needed for the accelerator is NOT included in the preferred width.
   int GetAcceleratorTextWidth();
 
   // Returns true if the menu has mnemonics. This only useful on the root menu
   // item.
   bool has_mnemonics() const { return has_mnemonics_; }
 
   // Set top and bottom margins in pixels.  If no margin is set or a
   // negative margin is specified then MenuConfig values are used.
-  void set_margins(int top_margin, int bottom_margin) {
+  virtual void set_margins(int top_margin, int bottom_margin) {
     top_margin_ = top_margin;
     bottom_margin_ = bottom_margin;
   }
 
   // Set the position of the menu with respect to the bounds (top
   // level only).
   void set_menu_position(MenuPosition menu_position) {
     requested_menu_position_ = menu_position;
   }
 
@@ skipping 157 matching lines @@
   // position of the menu being shown.
   MenuPosition requested_menu_position_;
   MenuPosition actual_menu_position_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuItemView);
 };
 
 }  // namespace views
 
 #endif  // VIEWS_CONTROLS_MENU_MENU_ITEM_VIEW_H_