GTK: Add Recently Closed tabs to the History menu in the global menu bar.

chrome/browser/ui/gtk/menu_gtk.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 CHROME_BROWSER_UI_GTK_MENU_GTK_H_
 #define CHROME_BROWSER_UI_GTK_MENU_GTK_H_
 #pragma once
 
 #include <gtk/gtk.h>
 
 #include <string>
 #include <vector>
 
 #include "base/task.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/gfx/point.h"
 
 class SkBitmap;
 
 namespace ui {
 class ButtonMenuItemModel;
 class MenuModel;
 }
 
-class MenuGtk {
+// We have multiple places in the code that actually build menus and have
+// wildly different requirements.
+class MenuCreator {

[Evan Stade, 2011/04/20 22:52:10]

can we call it GtkMenuCreator to make it more explicit it's creating the
GtkMenu? Also, it merits its own file(s).

+ public:
+  class Delegate {

[Evan Stade, 2011/04/20 22:52:10]

this should not be called Delegate. I think GtkMenuCreator::ModelExtras perhaps
makes more sense? I'm open to hearing your opinion here.

Previously the functions herein were part of MenuGtk::Delegate, but that's
probably just because it was the easiest place to tack them on.

+   public:
+    virtual ~Delegate() {}
+
+    // Return true if we should override the "gtk-menu-images" system setting
+    // when showing image menu items for this menu.
+    virtual bool AlwaysShowIconForCmd(int command_id) const { return false; }
+
+    // Returns an icon for the menu item, if available.
+    virtual GtkWidget* GetImageForCommandId(int command_id) const;
+
+    static GtkWidget* GetDefaultImageForCommandId(int command_id);

[Evan Stade, 2011/04/20 22:52:10]

I think this belongs on MenuCreator.

+  };
+
+ protected:
+  explicit MenuCreator(Delegate* delegate);
+  virtual ~MenuCreator();
+
+  // Creates the menu items specified in |model| and places them into |menu|.
+  void BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu);
+
+  // Builds a GtkImageMenuItem.
+  GtkWidget* BuildMenuItemWithImage(const std::string& label,
+                                    const SkBitmap& icon) const;
+
+  GtkWidget* BuildMenuItemWithImage(const std::string& label,
+                                    GtkWidget* image) const;
+
+  GtkWidget* BuildMenuItemWithLabel(const std::string& label,
+                                    int command_id) const;
+
+  // Called to build one of our custom menu button items. Some menus we
+  // construct can't support this type (due to tight integration with our
+  // GtkCustomMenu); in that case always return NULL.
+  virtual GtkWidget* BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
+                                         GtkWidget* menu) = 0;
+
+  // Called after every |menu_item| created. It's this method's responsibility
+  // to add the |menu_item| to |menu|, to hook up signals, etc.
+  virtual GtkWidget* AppendMenuItemToMenu(int index,
+                                          ui::MenuModel* model,
+                                          GtkWidget* menu_item,
+                                          GtkWidget* menu,
+                                          bool connect_to_activate) = 0;
+
+ private:
+  Delegate* delegate_;
+
+  // For some menu items, we want to show the accelerator, but not actually
+  // explicitly handle it. To this end we connect those menu items' accelerators
+  // to this group, but don't attach this group to any top level window.
+  GtkAccelGroup* dummy_accel_group_;
+};
+
+// MenuGtk both creates the menu.
+class MenuGtk : public MenuCreator {
  public:
   // Delegate class that lets another class control the status of the menu.
-  class Delegate {
+  class Delegate : public MenuCreator::Delegate {

[Evan Stade, 2011/04/20 22:52:10]

I don't think MenuGtk::Delegate needs to be a subclass of MenuCreator::Delegate
(or GtkMenuCreator::ModelExtras if you take my above suggestions). Any client
that actually wants to implement those things should implement both interfaces.

And yes, this means we need to add another constructor that takes a delegate,
model, and modelextras.

    public:
     virtual ~Delegate() { }
 
     // Called before a command is executed. This exists for the case where a
     // model is handling the actual execution of commands, but the delegate
     // still needs to know that some command got executed. This is called before
     // and not after the command is executed because its execution may delete
     // the menu and/or the delegate.
     virtual void CommandWillBeExecuted() {}
 
     // Called when the menu stops showing. This will be called before
     // ExecuteCommand if the user clicks an item, but will also be called when
     // the user clicks away from the menu.
     virtual void StoppedShowing() {}
 
-    // Return true if we should override the "gtk-menu-images" system setting
-    // when showing image menu items for this menu.
-    virtual bool AlwaysShowIconForCmd(int command_id) const { return false; }
-
     // Returns a tinted image used in button in a menu.
     virtual GtkIconSet* GetIconSetForId(int idr) { return NULL; }

[Evan Stade, 2011/04/20 22:52:10]

also belongs in ModelExtras

-
-    // Returns an icon for the menu item, if available.
-    virtual GtkWidget* GetImageForCommandId(int command_id) const;
-
-    static GtkWidget* GetDefaultImageForCommandId(int command_id);
   };
 
   MenuGtk(MenuGtk::Delegate* delegate, ui::MenuModel* model);
   ~MenuGtk();
 
   // Initialize GTK signal handlers.
   void ConnectSignalHandlers();
 
   // These methods are used to build the menu dynamically. The return value
   // is the new menu item.
   GtkWidget* AppendMenuItemWithLabel(int command_id, const std::string& label);
   GtkWidget* AppendMenuItemWithIcon(int command_id, const std::string& label,
                                     const SkBitmap& icon);
   GtkWidget* AppendCheckMenuItemWithLabel(int command_id,
                                           const std::string& label);
   GtkWidget* AppendSeparator();
   GtkWidget* AppendMenuItem(int command_id, GtkWidget* menu_item);
-  GtkWidget* AppendMenuItemToMenu(int index,
-                                  ui::MenuModel* model,
-                                  GtkWidget* menu_item,
-                                  GtkWidget* menu,
-                                  bool connect_to_activate);
 
   // Displays the menu near a widget, as if the widget were a menu bar.
   // Example: the wrench menu button.
   // |button| is the mouse button that brought up the menu.
   // |event_time| is the time from the GdkEvent.
   void PopupForWidget(GtkWidget* widget, int button, guint32 event_time);
 
   // Displays the menu as a context menu, i.e. at the cursor location.
   // It is implicit that it was brought up using the right mouse button.
   // |point| is the point where to put the menu.
@@ skipping 29 matching lines @@
                                     int* y,
                                     gboolean* push_in,
                                     gpointer userdata);
 
   GtkWidget* widget() const { return menu_; }
 
   // Updates all the enabled/checked states and the dynamic labels.
   void UpdateMenu();
 
  private:
-  // Builds a GtkImageMenuItem.
-  GtkWidget* BuildMenuItemWithImage(const std::string& label,
-                                    const SkBitmap& icon);
-
-  GtkWidget* BuildMenuItemWithImage(const std::string& label,
-                                    GtkWidget* image);
-
-  GtkWidget* BuildMenuItemWithLabel(const std::string& label,
-                                    int command_id);
-
   // A function that creates a GtkMenu from |model_|.
   void BuildMenuFromModel();
-  // Implementation of the above; called recursively.
-  void BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu);
-  // Builds a menu item with buttons in it from the data in the model.
-  GtkWidget* BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
-                                 GtkWidget* menu);
 
   void ExecuteCommand(ui::MenuModel* model, int id);
 
+  // MenuCreator:
+  virtual GtkWidget* AppendMenuItemToMenu(int index,
+                                          ui::MenuModel* model,
+                                          GtkWidget* menu_item,
+                                          GtkWidget* menu,
+                                          bool connect_to_activate);
+  virtual GtkWidget* BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
+                                         GtkWidget* menu);
+
   // Callback for when a menu item is clicked.
   CHROMEGTK_CALLBACK_0(MenuGtk, void, OnMenuItemActivated);
 
   // Called when one of the buttons are pressed.
   CHROMEGTK_CALLBACK_1(MenuGtk, void, OnMenuButtonPressed, int);
 
   // Called to maybe activate a button if that button isn't supposed to dismiss
   // the menu.
   CHROMEGTK_CALLBACK_1(MenuGtk, gboolean, OnMenuTryButtonPressed, int);
 
@@ skipping 10 matching lines @@
   // items.
   static void SetMenuItemInfo(GtkWidget* widget, void* raw_menu);
 
   // Queries this object about the menu state.
   MenuGtk::Delegate* delegate_;
 
   // If non-NULL, the MenuModel that we use to populate and control the GTK
   // menu (overriding the delegate as a controller).
   ui::MenuModel* model_;
 
-  // For some menu items, we want to show the accelerator, but not actually
-  // explicitly handle it. To this end we connect those menu items' accelerators
-  // to this group, but don't attach this group to any top level window.
-  GtkAccelGroup* dummy_accel_group_;
-
   // gtk_menu_popup() does not appear to take ownership of popup menus, so
   // MenuGtk explicitly manages the lifetime of the menu.
   GtkWidget* menu_;
 
   // True when we should ignore "activate" signals.  Used to prevent
   // menu items from getting activated when we are setting up the
   // menu.
   static bool block_activation_;
 
   // We must free these at shutdown.
   std::vector<MenuGtk*> submenus_we_own_;
 
   ScopedRunnableMethodFactory<MenuGtk> factory_;
 };
 
 #endif  // CHROME_BROWSER_UI_GTK_MENU_GTK_H_