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"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/gtk/gtk_custom_menu.h"
 #include "chrome/browser/ui/gtk/gtk_custom_menu_item.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/models/accelerator_gtk.h"
 #include "ui/base/models/button_menu_item_model.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/gtk_util.h"
 #include "webkit/glue/window_open_disposition.h"
 
@@ skipping 82 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) {
-  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:
-      stock = GTK_STOCK_CLOSE;
-      break;
-
-    case IDC_CONTENT_CONTEXT_SAVEIMAGEAS:
-    case IDC_CONTENT_CONTEXT_SAVEAVAS:
-    case IDC_CONTENT_CONTEXT_SAVELINKAS:
-      stock = GTK_STOCK_SAVE_AS;
-      break;
-
-    case IDC_SAVE_PAGE:
-      stock = GTK_STOCK_SAVE;
-      break;
-
-    case IDC_COPY:
-    case IDC_COPY_URL:
-    case IDC_CONTENT_CONTEXT_COPYIMAGELOCATION:
-    case IDC_CONTENT_CONTEXT_COPYLINKLOCATION:
-    case IDC_CONTENT_CONTEXT_COPYAVLOCATION:
-    case IDC_CONTENT_CONTEXT_COPYEMAILADDRESS:
-    case IDC_CONTENT_CONTEXT_COPY:
-      stock = GTK_STOCK_COPY;
-      break;
-
-    case IDC_CUT:
-    case IDC_CONTENT_CONTEXT_CUT:
-      stock = GTK_STOCK_CUT;
-      break;
-
-    case IDC_PASTE:
-    case IDC_CONTENT_CONTEXT_PASTE:
-      stock = GTK_STOCK_PASTE;
-      break;
-
-    case IDC_CONTENT_CONTEXT_DELETE:
-    case IDC_BOOKMARK_BAR_REMOVE:
-      stock = GTK_STOCK_DELETE;
-      break;
-
-    case IDC_CONTENT_CONTEXT_UNDO:
-      stock = GTK_STOCK_UNDO;
-      break;
-
-    case IDC_CONTENT_CONTEXT_REDO:
-      stock = GTK_STOCK_REDO;
-      break;
-
-    case IDC_SEARCH:
-    case IDC_FIND:
-    case IDC_CONTENT_CONTEXT_SEARCHWEBFOR:
-      stock = GTK_STOCK_FIND;
-      break;
-
-    case IDC_CONTENT_CONTEXT_SELECTALL:
-      stock = GTK_STOCK_SELECT_ALL;
-      break;
-
-    case IDC_CLEAR_BROWSING_DATA:
-      stock = GTK_STOCK_CLEAR;
-      break;
-
-    case IDC_BACK:
-      stock = GTK_STOCK_GO_BACK;
-      break;
-
-    case IDC_RELOAD:
-      stock = GTK_STOCK_REFRESH;
-      break;
-
-    case IDC_FORWARD:
-      stock = GTK_STOCK_GO_FORWARD;
-      break;
-
-    case IDC_PRINT:
-      stock = GTK_STOCK_PRINT;
-      break;
-
-    case IDC_CONTENT_CONTEXT_VIEWPAGEINFO:
-      stock = GTK_STOCK_INFO;
-      break;
-
-    case IDC_SPELLCHECK_MENU:
-      stock = GTK_STOCK_SPELL_CHECK;
-      break;
-
-    case IDC_RESTORE_TAB:
-      stock = GTK_STOCK_UNDELETE;
-      break;
-
-    case IDC_HOME:
-      stock = GTK_STOCK_HOME;
-      break;
-
-    case IDC_STOP:
-      stock = GTK_STOCK_STOP;
-      break;
-
-    case IDC_ABOUT:
-      stock = GTK_STOCK_ABOUT;
-      break;
-
-    case IDC_EXIT:
-      stock = GTK_STOCK_QUIT;
-      break;
-
-    case IDC_HELP_PAGE:
-      stock = GTK_STOCK_HELP;
-      break;
-
-    case IDC_OPTIONS:
-      stock = GTK_STOCK_PREFERENCES;
-      break;
-
-    case IDC_CONTENT_CONTEXT_GOTOURL:
-      stock = GTK_STOCK_JUMP_TO;
-      break;
-
-    case IDC_DEV_TOOLS_INSPECT:
-    case IDC_CONTENT_CONTEXT_INSPECTELEMENT:
-      stock = GTK_STOCK_PROPERTIES;
-      break;
-
-    case IDC_BOOKMARK_BAR_ADD_NEW_BOOKMARK:
-      stock = GTK_STOCK_ADD;
-      break;
-
-    case IDC_BOOKMARK_BAR_RENAME_FOLDER:
-    case IDC_BOOKMARK_BAR_EDIT:
-      stock = GTK_STOCK_EDIT;
-      break;
-
-    case IDC_BOOKMARK_BAR_NEW_FOLDER:
-      stock = GTK_STOCK_DIRECTORY;
-      break;
-
-    case IDC_BOOKMARK_BAR_OPEN_ALL:
-      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 {
-  return GetDefaultImageForCommandId(command_id);
-}
-
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  ui::MenuModel* model)
-    : delegate_(delegate),
+    : GtkMenuCreator(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 24 matching lines @@
   gtk_widget_show(menu_item);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_), menu_item);
   return menu_item;
 }
 
 GtkWidget* MenuGtk::AppendMenuItem(int command_id, GtkWidget* menu_item) {
   if (delegate_ && delegate_->AlwaysShowIconForCmd(command_id) &&
       GTK_IS_IMAGE_MENU_ITEM(menu_item))
     gtk_util::SetAlwaysShowImage(menu_item);
 
-  return AppendMenuItemToMenu(command_id, NULL, menu_item, menu_, true);
+  gtk_menu_shell_append(GTK_MENU_SHELL(menu_), menu_item);
+  return AppendMenuItemToMenu(command_id, NULL, menu_item, menu_);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemToMenu(int index,
                                          ui::MenuModel* model,
                                          GtkWidget* menu_item,
-                                         GtkWidget* menu,
-                                         bool connect_to_activate) {
+                                         GtkWidget* menu) {
   SetMenuItemID(menu_item, index);
 
   // Native menu items do their own thing, so only selectively listen for the
   // activate signal.
-  if (connect_to_activate) {
+  if (!model ||
+      model->GetTypeAt(index) != ui::MenuModel::TYPE_BUTTON_ITEM) {
     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) {

[Evan Stade, 2011/04/25 20:08:22]

if (!model || model->IsVisibleAt(index))

     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);
+
   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);
     }
   }
 }