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

chrome/browser/ui/gtk/menu_gtk.cc

 // 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.
 
 #include "chrome/browser/ui/gtk/menu_gtk.h"
 
 #include <map>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
@@ skipping 96 matching lines @@
   int alternate_y = y - menu_req->height;
   if (widget)
     alternate_y -= widget->allocation.height;
   if (menu_bottom >= screen_bottom && alternate_y >= screen_top)
     return alternate_y;
   return y;
 }
 
 }  // namespace
 
-GtkWidget* MenuGtk::Delegate::GetDefaultImageForCommandId(int command_id) {
+GtkWidget* MenuCreator::Delegate::GetDefaultImageForCommandId(int command_id) {
   const char* stock;
   switch (command_id) {
     case IDC_NEW_TAB:
     case IDC_CONTENT_CONTEXT_OPENIMAGENEWTAB:
     case IDC_CONTENT_CONTEXT_OPENLINKNEWTAB:
     case IDC_CONTENT_CONTEXT_OPENAVNEWTAB:
       stock = GTK_STOCK_NEW;
       break;
 
     case IDC_CLOSE_TAB:
@@ skipping 135 matching lines @@
       stock = GTK_STOCK_OPEN;
       break;
 
     default:
       stock = NULL;
   }
 
   return stock ? gtk_image_new_from_stock(stock, GTK_ICON_SIZE_MENU) : NULL;
 }
 
-GtkWidget* MenuGtk::Delegate::GetImageForCommandId(int command_id) const {
+GtkWidget* MenuCreator::Delegate::GetImageForCommandId(int command_id) const {
   return GetDefaultImageForCommandId(command_id);
 }
 
+MenuCreator::MenuCreator(Delegate* delegate)
+    : delegate_(delegate),
+      dummy_accel_group_(gtk_accel_group_new()) {
+}
+
+MenuCreator::~MenuCreator() {
+  g_object_unref(dummy_accel_group_);
+}
+
+void MenuCreator::BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu) {
+  std::map<int, GtkWidget*> radio_groups;
+  GtkWidget* menu_item = NULL;
+  for (int i = 0; i < model->GetItemCount(); ++i) {
+    SkBitmap icon;
+    std::string label =
+        gfx::ConvertAcceleratorsFromWindowsStyle(
+            UTF16ToUTF8(model->GetLabelAt(i)));
+    bool connect_to_activate = true;
+
+    switch (model->GetTypeAt(i)) {
+      case ui::MenuModel::TYPE_SEPARATOR:
+        menu_item = gtk_separator_menu_item_new();
+        break;
+
+      case ui::MenuModel::TYPE_CHECK:
+        menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
+        break;
+
+      case ui::MenuModel::TYPE_RADIO: {
+        std::map<int, GtkWidget*>::iterator iter =
+            radio_groups.find(model->GetGroupIdAt(i));
+
+        if (iter == radio_groups.end()) {
+          menu_item = gtk_radio_menu_item_new_with_mnemonic(
+              NULL, label.c_str());
+          radio_groups[model->GetGroupIdAt(i)] = menu_item;
+        } else {
+          menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget(
+              GTK_RADIO_MENU_ITEM(iter->second), label.c_str());
+        }
+        break;
+      }
+      case ui::MenuModel::TYPE_BUTTON_ITEM: {
+        ui::ButtonMenuItemModel* button_menu_item_model =
+            model->GetButtonMenuItemAt(i);
+        menu_item = BuildButtonMenuItem(button_menu_item_model, menu);
+        if (!menu_item)
+          continue;
+        connect_to_activate = false;
+        break;
+      }
+      case ui::MenuModel::TYPE_SUBMENU:
+      case ui::MenuModel::TYPE_COMMAND: {
+        int command_id = model->GetCommandIdAt(i);
+        if (model->GetIconAt(i, &icon))
+          menu_item = BuildMenuItemWithImage(label, icon);
+        else
+          menu_item = BuildMenuItemWithLabel(label, command_id);
+        if (delegate_ && delegate_->AlwaysShowIconForCmd(command_id) &&
+            GTK_IS_IMAGE_MENU_ITEM(menu_item))
+          gtk_util::SetAlwaysShowImage(menu_item);
+        break;
+      }
+
+      default:
+        NOTREACHED();
+    }
+
+    if (model->GetTypeAt(i) == ui::MenuModel::TYPE_SUBMENU) {
+      GtkWidget* submenu = gtk_menu_new();
+      BuildSubmenuFromModel(model->GetSubmenuModelAt(i), submenu);
+      gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
+    }
+
+    ui::AcceleratorGtk accelerator;
+    if (model->GetAcceleratorAt(i, &accelerator)) {
+      gtk_widget_add_accelerator(menu_item,
+                                 "activate",
+                                 dummy_accel_group_,
+                                 accelerator.GetGdkKeyCode(),
+                                 accelerator.gdk_modifier_type(),
+                                 GTK_ACCEL_VISIBLE);
+    }
+
+    g_object_set_data(G_OBJECT(menu_item), "model", model);
+    AppendMenuItemToMenu(i, model, menu_item, menu, connect_to_activate);
+
+    menu_item = NULL;
+  }
+}
+
+GtkWidget* MenuCreator::BuildMenuItemWithImage(const std::string& label,
+                                               GtkWidget* image) const {
+  GtkWidget* menu_item =
+      gtk_image_menu_item_new_with_mnemonic(label.c_str());
+  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image);
+  return menu_item;
+}
+
+GtkWidget* MenuCreator::BuildMenuItemWithImage(const std::string& label,
+                                               const SkBitmap& icon) const {
+  GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
+  GtkWidget* menu_item = BuildMenuItemWithImage(label,
+      gtk_image_new_from_pixbuf(pixbuf));
+  g_object_unref(pixbuf);
+  return menu_item;
+}
+
+GtkWidget* MenuCreator::BuildMenuItemWithLabel(const std::string& label,
+                                               int command_id) const {
+  GtkWidget* img =
+      delegate_ ? delegate_->GetImageForCommandId(command_id) :
+                  MenuGtk::Delegate::GetDefaultImageForCommandId(command_id);
+  return img ? BuildMenuItemWithImage(label, img) :
+               gtk_menu_item_new_with_mnemonic(label.c_str());
+}
+
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  ui::MenuModel* model)
-    : delegate_(delegate),
+    : MenuCreator(delegate),
+      delegate_(delegate),
       model_(model),
-      dummy_accel_group_(gtk_accel_group_new()),
       menu_(gtk_custom_menu_new()),
       factory_(this) {
   DCHECK(model);
   g_object_ref_sink(menu_);
   ConnectSignalHandlers();
   BuildMenuFromModel();
 }
 
 MenuGtk::~MenuGtk() {
   Cancel();
 
   gtk_widget_destroy(menu_);
   g_object_unref(menu_);
 
   STLDeleteContainerPointers(submenus_we_own_.begin(), submenus_we_own_.end());
-  g_object_unref(dummy_accel_group_);
 }
 
 void MenuGtk::ConnectSignalHandlers() {
   // We connect afterwards because OnMenuShow calls SetMenuItemInfo, which may
   // take a long time or even start a nested message loop.
   g_signal_connect(menu_, "show", G_CALLBACK(OnMenuShowThunk), this);
   g_signal_connect(menu_, "hide", G_CALLBACK(OnMenuHiddenThunk), this);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemWithLabel(int command_id,
@@ skipping 31 matching lines @@
       GTK_IS_IMAGE_MENU_ITEM(menu_item))
     gtk_util::SetAlwaysShowImage(menu_item);
 
   return AppendMenuItemToMenu(command_id, NULL, menu_item, menu_, true);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemToMenu(int index,
                                          ui::MenuModel* model,
                                          GtkWidget* menu_item,
                                          GtkWidget* menu,
                                          bool connect_to_activate) {

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

this doesn't need to be passed here; check model->GetTypeAt(i) ==
ui::MenuModel::TYPE_BUTTON_ITEM

   SetMenuItemID(menu_item, index);
 
   // Native menu items do their own thing, so only selectively listen for the
   // activate signal.
   if (connect_to_activate) {
     g_signal_connect(menu_item, "activate",
                      G_CALLBACK(OnMenuItemActivatedThunk), this);
   }
 
   // AppendMenuItemToMenu is used both internally when we control menu creation
   // from a model (where the model can choose to hide certain menu items), and
   // with immediate commands which don't provide the option.
   if (model) {
     if (model->IsVisibleAt(index))
       gtk_widget_show(menu_item);
   } else {
     gtk_widget_show(menu_item);
   }
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);

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

is it necessary to do this here? why not do this in menucreator and then change
the function to "MenuItemCreated"

   return menu_item;
 }
 
 void MenuGtk::PopupForWidget(GtkWidget* widget, int button,
                              guint32 event_time) {
   gtk_menu_popup(GTK_MENU(menu_), NULL, NULL,
                  WidgetMenuPositionFunc,
                  widget,
                  button, event_time);
 }
@@ skipping 18 matching lines @@
 }
 
 void MenuGtk::Cancel() {
   gtk_menu_popdown(GTK_MENU(menu_));
 }
 
 void MenuGtk::UpdateMenu() {
   gtk_container_foreach(GTK_CONTAINER(menu_), SetMenuItemInfo, this);
 }
 
-GtkWidget* MenuGtk::BuildMenuItemWithImage(const std::string& label,
-                                  GtkWidget* image) {
-  GtkWidget* menu_item =
-      gtk_image_menu_item_new_with_mnemonic(label.c_str());
-  gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image);
-  return menu_item;
-}
-
-GtkWidget* MenuGtk::BuildMenuItemWithImage(const std::string& label,
-                                           const SkBitmap& icon) {
-  GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
-  GtkWidget* menu_item = BuildMenuItemWithImage(label,
-      gtk_image_new_from_pixbuf(pixbuf));
-  g_object_unref(pixbuf);
-  return menu_item;
-}
-
-GtkWidget* MenuGtk::BuildMenuItemWithLabel(const std::string& label,
-                                           int command_id) {
-  GtkWidget* img =
-      delegate_ ? delegate_->GetImageForCommandId(command_id) :
-                  MenuGtk::Delegate::GetDefaultImageForCommandId(command_id);
-  return img ? BuildMenuItemWithImage(label, img) :
-               gtk_menu_item_new_with_mnemonic(label.c_str());
-}
-
 void MenuGtk::BuildMenuFromModel() {
   BuildSubmenuFromModel(model_, menu_);
 }
 
-void MenuGtk::BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu) {
-  std::map<int, GtkWidget*> radio_groups;
-  GtkWidget* menu_item = NULL;
-  for (int i = 0; i < model->GetItemCount(); ++i) {
-    SkBitmap icon;
-    std::string label =
-        gfx::ConvertAcceleratorsFromWindowsStyle(
-            UTF16ToUTF8(model->GetLabelAt(i)));
-    bool connect_to_activate = true;
-
-    switch (model->GetTypeAt(i)) {
-      case ui::MenuModel::TYPE_SEPARATOR:
-        menu_item = gtk_separator_menu_item_new();
-        break;
-
-      case ui::MenuModel::TYPE_CHECK:
-        menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
-        break;
-
-      case ui::MenuModel::TYPE_RADIO: {
-        std::map<int, GtkWidget*>::iterator iter =
-            radio_groups.find(model->GetGroupIdAt(i));
-
-        if (iter == radio_groups.end()) {
-          menu_item = gtk_radio_menu_item_new_with_mnemonic(
-              NULL, label.c_str());
-          radio_groups[model->GetGroupIdAt(i)] = menu_item;
-        } else {
-          menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget(
-              GTK_RADIO_MENU_ITEM(iter->second), label.c_str());
-        }
-        break;
-      }
-      case ui::MenuModel::TYPE_BUTTON_ITEM: {
-        ui::ButtonMenuItemModel* button_menu_item_model =
-            model->GetButtonMenuItemAt(i);
-        menu_item = BuildButtonMenuItem(button_menu_item_model, menu);
-        connect_to_activate = false;
-        break;
-      }
-      case ui::MenuModel::TYPE_SUBMENU:
-      case ui::MenuModel::TYPE_COMMAND: {
-        int command_id = model->GetCommandIdAt(i);
-        if (model->GetIconAt(i, &icon))
-          menu_item = BuildMenuItemWithImage(label, icon);
-        else
-          menu_item = BuildMenuItemWithLabel(label, command_id);
-        if (delegate_ && delegate_->AlwaysShowIconForCmd(command_id) &&
-            GTK_IS_IMAGE_MENU_ITEM(menu_item))
-          gtk_util::SetAlwaysShowImage(menu_item);
-        break;
-      }
-
-      default:
-        NOTREACHED();
-    }
-
-    if (model->GetTypeAt(i) == ui::MenuModel::TYPE_SUBMENU) {
-      GtkWidget* submenu = gtk_menu_new();
-      BuildSubmenuFromModel(model->GetSubmenuModelAt(i), submenu);
-      gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), submenu);
-    }
-
-    ui::AcceleratorGtk accelerator;
-    if (model->GetAcceleratorAt(i, &accelerator)) {
-      gtk_widget_add_accelerator(menu_item,
-                                 "activate",
-                                 dummy_accel_group_,
-                                 accelerator.GetGdkKeyCode(),
-                                 accelerator.gdk_modifier_type(),
-                                 GTK_ACCEL_VISIBLE);
-    }
-
-    g_object_set_data(G_OBJECT(menu_item), "model", model);
-    AppendMenuItemToMenu(i, model, menu_item, menu, connect_to_activate);
-
-    menu_item = NULL;
-  }
-}
-
 GtkWidget* MenuGtk::BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
                                         GtkWidget* menu) {
   GtkWidget* menu_item = gtk_custom_menu_item_new(
       gfx::RemoveWindowsStyleAccelerators(UTF16ToUTF8(model->label())).c_str());
 
   // Set up the callback to the model for when it is clicked.
   g_object_set_data(G_OBJECT(menu_item), "button-model", model);
   g_signal_connect(menu_item, "button-pushed",
                    G_CALLBACK(OnMenuButtonPressedThunk), this);
   g_signal_connect(menu_item, "try-button-pushed",
@@ skipping 296 matching lines @@
       gtk_widget_hide(widget);
     }
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
                             userdata);
     }
   }
 }