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

chrome/browser/ui/gtk/global_menu_bar.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/global_menu_bar.h"
 
 #include <gtk/gtk.h>
 
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/accelerators_gtk.h"
+#include "chrome/browser/ui/gtk/gtk_util.h"
+#include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/common/pref_names.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/gtk_util.h"
 
-struct GlobalMenuBarCommand {
-  int str_id;
-  int command;
-};
-
-namespace {
-
-const int MENU_SEPARATOR =-1;
-const int MENU_END = -2;
-
-GlobalMenuBarCommand file_menu[] = {
-  { IDS_NEW_TAB, IDC_NEW_TAB },
-  { IDS_NEW_WINDOW, IDC_NEW_WINDOW },
-  { IDS_NEW_INCOGNITO_WINDOW, IDC_NEW_INCOGNITO_WINDOW },
-  { IDS_REOPEN_CLOSED_TABS_LINUX, IDC_RESTORE_TAB },
-  { IDS_OPEN_FILE_LINUX, IDC_OPEN_FILE },
-  { IDS_OPEN_LOCATION_LINUX, IDC_FOCUS_LOCATION },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_CREATE_SHORTCUTS, IDC_CREATE_SHORTCUTS },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_CLOSE_WINDOW_LINUX, IDC_CLOSE_WINDOW },
-  { IDS_CLOSE_TAB_LINUX, IDC_CLOSE_TAB },
-  { IDS_SAVE_PAGE, IDC_SAVE_PAGE },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_PRINT, IDC_PRINT },
-
-  { MENU_END, MENU_END }
-};
-
-// TODO(erg): Need to add support for undo/redo/other editing commands that
-// don't go through the command id framework.
-GlobalMenuBarCommand edit_menu[] = {
-  // TODO(erg): Undo
-  // TODO(erg): Redo
-
-  // TODO(erg): Separator
-
-  { IDS_CUT, IDC_CUT },
-  { IDS_COPY, IDC_COPY },
-  { IDS_PASTE, IDC_PASTE },
-  // TODO(erg): Delete
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  // TODO(erg): Select All
-  // TODO(erg): Another separator
-
-  { IDS_FIND, IDC_FIND },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_PREFERENCES, IDC_OPTIONS },
-
-  { MENU_END, MENU_END }
-};
-
-// TODO(erg): The View menu should be overhauled and based on the Firefox view
-// menu.
-GlobalMenuBarCommand view_menu[] = {
-  { IDS_SHOW_BOOKMARK_BAR, IDC_SHOW_BOOKMARK_BAR },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_STOP_MENU_LINUX, IDC_STOP },
-  { IDS_RELOAD_MENU_LINUX, IDC_RELOAD },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_FULLSCREEN, IDC_FULLSCREEN },
-  { IDS_TEXT_DEFAULT_LINUX, IDC_ZOOM_NORMAL },
-  { IDS_TEXT_BIGGER_LINUX, IDC_ZOOM_PLUS },
-  { IDS_TEXT_SMALLER_LINUX, IDC_ZOOM_MINUS },
-
-  { MENU_END, MENU_END }
-};
-
-GlobalMenuBarCommand tools_menu[] = {
-  { IDS_SHOW_DOWNLOADS, IDC_SHOW_DOWNLOADS },
-  { IDS_SHOW_HISTORY, IDC_SHOW_HISTORY },
-  { IDS_SHOW_EXTENSIONS, IDC_MANAGE_EXTENSIONS },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_TASK_MANAGER, IDC_TASK_MANAGER },
-  { IDS_CLEAR_BROWSING_DATA, IDC_CLEAR_BROWSING_DATA },
-
-  { MENU_SEPARATOR, MENU_SEPARATOR },
-
-  { IDS_VIEW_SOURCE, IDC_VIEW_SOURCE },
-  { IDS_DEV_TOOLS, IDC_DEV_TOOLS },
-  { IDS_DEV_TOOLS_CONSOLE, IDC_DEV_TOOLS_CONSOLE },
-
-  { MENU_END, MENU_END }
-};
-
-GlobalMenuBarCommand help_menu[] = {
-  { IDS_FEEDBACK, IDC_FEEDBACK },
-  { IDS_HELP_PAGE , IDC_HELP_PAGE },
-  { MENU_END, MENU_END }
-};
-
-}  // namespace
-
-GlobalMenuBar::GlobalMenuBar(Browser* browser,
-                             BrowserWindowGtk* window)
-    : browser_(browser),
-      browser_window_(window),
+GlobalMenuBar::GlobalMenuBar(Browser* browser)
+    : GtkMenuCreator(this),
+      browser_(browser),
+      profile_(browser_->profile()),
       menu_bar_(gtk_menu_bar_new()),
-      dummy_accel_group_(gtk_accel_group_new()),
+      history_menu_(browser_),
       block_activation_(false) {
   // The global menu bar should never actually be shown in the app; it should
   // instead remain in our widget hierarchy simply to be noticed by third party
   // components.
-  gtk_widget_set_no_show_all(menu_bar_, TRUE);
+  gtk_widget_set_no_show_all(menu_bar_.get(), TRUE);
+  gtk_widget_show(menu_bar_.get());
 
   // Set a nice name so it shows up in gtkparasite and others.
-  gtk_widget_set_name(menu_bar_, "chrome-hidden-global-menubar");
+  gtk_widget_set_name(menu_bar_.get(), "chrome-hidden-global-menubar");
 
-  BuildGtkMenuFrom(IDS_FILE_MENU_LINUX, &id_to_menu_item_, file_menu);
-  BuildGtkMenuFrom(IDS_EDIT_MENU_LINUX, &id_to_menu_item_, edit_menu);
-  BuildGtkMenuFrom(IDS_VIEW_MENU_LINUX, &id_to_menu_item_, view_menu);
-  BuildGtkMenuFrom(IDS_TOOLS_MENU_LINUX, &id_to_menu_item_, tools_menu);
-  BuildGtkMenuFrom(IDS_HELP_MENU_LINUX, &id_to_menu_item_, help_menu);
+  // File menu
+  ui::SimpleMenuModel file_menu_model(this);
+  file_menu_model.AddItemWithStringId(IDC_NEW_TAB, IDS_NEW_TAB);
+  file_menu_model.AddItemWithStringId(IDC_NEW_WINDOW, IDS_NEW_WINDOW);
+  file_menu_model.AddItemWithStringId(IDC_NEW_INCOGNITO_WINDOW,
+                                      IDS_NEW_INCOGNITO_WINDOW);
+  file_menu_model.AddItemWithStringId(IDC_RESTORE_TAB,
+                                      IDS_REOPEN_CLOSED_TABS_LINUX);
+  file_menu_model.AddItemWithStringId(IDC_OPEN_FILE, IDS_OPEN_FILE_LINUX);
+  file_menu_model.AddItemWithStringId(IDC_FOCUS_LOCATION,
+                                      IDS_OPEN_LOCATION_LINUX);
+  file_menu_model.AddSeparator();
+  file_menu_model.AddItemWithStringId(IDC_CREATE_SHORTCUTS,
+                                      IDS_CREATE_SHORTCUTS);
+  file_menu_model.AddSeparator();
+  file_menu_model.AddItemWithStringId(IDC_CLOSE_WINDOW,
+                                      IDS_CLOSE_WINDOW_LINUX);
+  file_menu_model.AddItemWithStringId(IDC_CLOSE_TAB,
+                                      IDS_CLOSE_TAB_LINUX);
+  file_menu_model.AddItemWithStringId(IDC_SAVE_PAGE, IDS_SAVE_PAGE);
+  file_menu_model.AddSeparator();
+  file_menu_model.AddItemWithStringId(IDC_PRINT, IDS_PRINT);
+  BuildGtkMenuFrom(IDS_FILE_MENU_LINUX, &file_menu_model);
 
-  for (IDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
+  ui::SimpleMenuModel edit_menu_model(this);
+  // TODO(erg): Undo/Redo/Separator
+  edit_menu_model.AddItemWithStringId(IDC_CUT, IDS_CUT);
+  edit_menu_model.AddItemWithStringId(IDC_COPY, IDS_COPY);
+  edit_menu_model.AddItemWithStringId(IDC_PASTE, IDS_PASTE);
+  // TODO(erg): Delete/Seperator/Select All/Seperator
+  edit_menu_model.AddSeparator();
+  edit_menu_model.AddItemWithStringId(IDC_FIND, IDS_FIND);
+  edit_menu_model.AddSeparator();
+  edit_menu_model.AddItemWithStringId(IDC_OPTIONS, IDS_PREFERENCES);
+  BuildGtkMenuFrom(IDS_EDIT_MENU_LINUX, &edit_menu_model);
+
+  ui::SimpleMenuModel view_menu_model(this);
+  view_menu_model.AddCheckItemWithStringId(IDC_SHOW_BOOKMARK_BAR,
+                                           IDS_SHOW_BOOKMARK_BAR);
+  view_menu_model.AddSeparator();
+  view_menu_model.AddItemWithStringId(IDC_STOP, IDS_STOP_MENU_LINUX);
+  view_menu_model.AddItemWithStringId(IDC_RELOAD, IDS_RELOAD_MENU_LINUX);
+  view_menu_model.AddSeparator();
+  view_menu_model.AddItemWithStringId(IDC_FULLSCREEN, IDS_FULLSCREEN);
+  view_menu_model.AddItemWithStringId(IDC_ZOOM_NORMAL, IDS_TEXT_DEFAULT_LINUX);
+  view_menu_model.AddItemWithStringId(IDC_ZOOM_PLUS, IDS_TEXT_BIGGER_LINUX);
+  view_menu_model.AddItemWithStringId(IDC_ZOOM_MINUS, IDS_TEXT_SMALLER_LINUX);
+  BuildGtkMenuFrom(IDS_VIEW_MENU_LINUX, &view_menu_model);
+
+  ui::SimpleMenuModel history_menu_model(this);
+  history_menu_model.AddItemWithStringId(IDC_HOME, IDS_HISTORY_HOME_LINUX);
+  history_menu_model.AddItemWithStringId(IDC_BACK, IDS_HISTORY_BACK_LINUX);
+  history_menu_model.AddItemWithStringId(IDC_FORWARD,
+                                         IDS_HISTORY_FORWARD_LINUX);
+  history_menu_model.AddSeparator();
+  history_menu_model.AddItemWithStringId(TAG_MOST_VISITED_HEADER,
+                                         IDS_HISTORY_VISITED_LINUX);
+  history_menu_model.AddSeparator();
+  history_menu_model.AddItemWithStringId(TAG_RECENTLY_CLOSED_HEADER,
+                                         IDS_HISTORY_CLOSED_LINUX);
+  history_menu_model.AddSeparator();
+  history_menu_model.AddItemWithStringId(IDC_SHOW_HISTORY,
+                                         IDS_SHOWFULLHISTORY_LINK);
+  history_menu_.Init(BuildGtkMenuFrom(IDS_HISTORY_MENU_LINUX,
+                                      &history_menu_model));
+
+  ui::SimpleMenuModel bookmark_menu_model(this);
+  bookmark_menu_model.AddItemWithStringId(IDC_SHOW_BOOKMARK_MANAGER,
+                                          IDS_BOOKMARK_MANAGER);
+  bookmark_menu_model.AddItemWithStringId(IDC_BOOKMARK_PAGE,
+                                          IDS_BOOKMARK_CURRENT_PAGE_LINUX);
+  bookmark_menu_model.AddItemWithStringId(IDC_BOOKMARK_ALL_TABS,
+                                          IDS_BOOKMARK_ALL_TABS_LINUX);
+  bookmark_menu_model.AddSeparator();
+  // TODO(erg): Real implementation of bookmark bar bookmarks!
+  bookmark_menu_model.AddSeparator();
+  bookmark_menu_model.AddItemWithStringId(IDC_BOOKMARK_BAR_OPEN_ALL,
+                                          IDS_BOOMARK_BAR_OPEN_ALL);
+  bookmark_menu_model.AddItemWithStringId(IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW,
+                                          IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW);
+  bookmark_menu_model.AddItemWithStringId(IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO,
+                                          IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO);
+  bookmark_menu_model.AddSeparator();
+  BuildGtkMenuFrom(IDS_BOOKMARKS_MENU_LINUX, &bookmark_menu_model);
+
+  ui::SimpleMenuModel tools_menu_model(this);
+  tools_menu_model.AddItemWithStringId(IDC_SHOW_DOWNLOADS, IDS_SHOW_DOWNLOADS);
+  tools_menu_model.AddItemWithStringId(IDC_SHOW_HISTORY, IDS_SHOW_HISTORY);
+  tools_menu_model.AddItemWithStringId(IDC_MANAGE_EXTENSIONS,
+                                       IDS_SHOW_EXTENSIONS);
+  tools_menu_model.AddSeparator();
+  tools_menu_model.AddItemWithStringId(IDC_TASK_MANAGER, IDS_TASK_MANAGER);
+  tools_menu_model.AddItemWithStringId(IDC_CLEAR_BROWSING_DATA,
+                                       IDS_CLEAR_BROWSING_DATA);
+  tools_menu_model.AddSeparator();
+  tools_menu_model.AddItemWithStringId(IDC_VIEW_SOURCE, IDS_VIEW_SOURCE);
+  tools_menu_model.AddItemWithStringId(IDC_DEV_TOOLS, IDS_DEV_TOOLS);
+  tools_menu_model.AddItemWithStringId(IDC_DEV_TOOLS_CONSOLE,
+                                       IDS_DEV_TOOLS_CONSOLE);
+  BuildGtkMenuFrom(IDS_TOOLS_MENU_LINUX, &tools_menu_model);
+
+  ui::SimpleMenuModel help_menu_model(this);
+  help_menu_model.AddItemWithStringId(IDC_FEEDBACK, IDS_FEEDBACK);
+  help_menu_model.AddItemWithStringId(IDC_HELP_PAGE, IDS_HELP_PAGE);
+  BuildGtkMenuFrom(IDS_HELP_MENU_LINUX, &help_menu_model);
+
+  for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     // Get the starting enabled state.
     gtk_widget_set_sensitive(
         it->second,
         browser_->command_updater()->IsCommandEnabled(it->first));
 
-    // Set the accelerator for each menu item.
-    const ui::AcceleratorGtk* accelerator_gtk =
-        AcceleratorsGtk::GetInstance()->GetPrimaryAcceleratorForCommand(
-            it->first);
-    if (accelerator_gtk) {
-      gtk_widget_add_accelerator(it->second,
-                                 "activate",
-                                 dummy_accel_group_,
-                                 accelerator_gtk->GetGdkKeyCode(),
-                                 accelerator_gtk->gdk_modifier_type(),
-                                 GTK_ACCEL_VISIBLE);
-    }
-
     browser_->command_updater()->AddCommandObserver(it->first, this);
   }
 
   // Listen for bookmark bar visibility changes and set the initial state.
   registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
   Observe(NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
           NotificationService::AllSources(),
           NotificationService::NoDetails());
 }
 
 GlobalMenuBar::~GlobalMenuBar() {
-  for (IDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
+  for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     browser_->command_updater()->RemoveCommandObserver(it->first, this);
   }
-
-  g_object_unref(dummy_accel_group_);
 }
 
-void GlobalMenuBar::BuildGtkMenuFrom(int menu_str_id,
-                                     std::map<int, GtkWidget*>* id_to_menu_item,
-                                     GlobalMenuBarCommand* commands) {
+GtkWidget* GlobalMenuBar::BuildGtkMenuFrom(
+    int menu_str_id,
+    ui::MenuModel* model) {
   GtkWidget* menu = gtk_menu_new();
-  for (int i = 0; commands[i].str_id != MENU_END; ++i) {
-    GtkWidget* menu_item = NULL;
-    if (commands[i].str_id == MENU_SEPARATOR) {
-      menu_item = gtk_separator_menu_item_new();
-    } else {
-      int command_id = commands[i].command;
-      std::string label =
-          gfx::ConvertAcceleratorsFromWindowsStyle(
-              l10n_util::GetStringUTF8(commands[i].str_id));
-
-      if (command_id == IDC_SHOW_BOOKMARK_BAR)
-        menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
-      else
-        menu_item = gtk_menu_item_new_with_mnemonic(label.c_str());
-
-      id_to_menu_item->insert(std::make_pair(command_id, menu_item));
-      g_object_set_data(G_OBJECT(menu_item), "command-id",
-                        GINT_TO_POINTER(command_id));
-      g_signal_connect(menu_item, "activate",
-                       G_CALLBACK(OnItemActivatedThunk), this);
-    }
-    gtk_widget_show(menu_item);
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
-  }
-
+  BuildSubmenuFromModel(model, menu);
   gtk_widget_show(menu);
 
   GtkWidget* menu_item = gtk_menu_item_new_with_mnemonic(
       gfx::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(menu_str_id)).c_str());
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
   gtk_widget_show(menu_item);
+  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar_.get()), menu_item);
 
-  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar_), menu_item);
+  return menu;
 }
 
 void GlobalMenuBar::EnabledStateChangedForCommand(int id, bool enabled) {
-  IDMenuItemMap::iterator it = id_to_menu_item_.find(id);
+  CommandIDMenuItemMap::iterator it = id_to_menu_item_.find(id);
   if (it != id_to_menu_item_.end())
     gtk_widget_set_sensitive(it->second, enabled);
 }
 
 void GlobalMenuBar::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
   DCHECK(type.value == NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED);
 
-  IDMenuItemMap::iterator it = id_to_menu_item_.find(IDC_SHOW_BOOKMARK_BAR);
+  CommandIDMenuItemMap::iterator it =
+      id_to_menu_item_.find(IDC_SHOW_BOOKMARK_BAR);
   if (it != id_to_menu_item_.end()) {
     PrefService* prefs = browser_->profile()->GetPrefs();
 
     block_activation_ = true;
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(it->second),
-                                   prefs->GetBoolean(prefs::kShowBookmarkBar));
+    gtk_check_menu_item_set_active(
+        GTK_CHECK_MENU_ITEM(it->second),
+        prefs->GetBoolean(prefs::kShowBookmarkBar));
     block_activation_ = false;
   }
 }
 
+GtkWidget* GlobalMenuBar::BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
+                                              GtkWidget* menu) {
+  // We don't host the menu items so we can never use buttons.
+  return NULL;
+}
+
+GtkWidget* GlobalMenuBar::AppendMenuItemToMenu(int index,
+                                               ui::MenuModel* model,
+                                               GtkWidget* menu_item,
+                                               GtkWidget* menu) {
+  int command_id = model->GetCommandIdAt(index);
+
+  // A few labels are always disabled and not connected to anything. They
+  // require special handling since they're signposts for the history menu's
+  // dynamic items.
+  if (command_id == TAG_MOST_VISITED_HEADER ||
+      command_id == TAG_RECENTLY_CLOSED_HEADER) {
+    g_object_set_data(G_OBJECT(menu_item), "type-tag",
+                      GINT_TO_POINTER(command_id));
+    gtk_widget_set_sensitive(menu_item, FALSE);
+  } else {
+    if (command_id != -1) {
+      id_to_menu_item_.insert(std::make_pair(command_id, menu_item));
+      g_object_set_data(G_OBJECT(menu_item), "command-id",
+                        GINT_TO_POINTER(command_id));
+    }
+
+    g_signal_connect(menu_item, "activate",
+                     G_CALLBACK(OnItemActivatedThunk), this);
+  }
+
+  gtk_widget_show(menu_item);
+
+  return menu_item;
+}
+
+bool GlobalMenuBar::IsCommandIdChecked(int command_id) const {
+  return false;
+}
+
+bool GlobalMenuBar::IsCommandIdEnabled(int command_id) const {
+  return true;
+}
+
+bool GlobalMenuBar::GetAcceleratorForCommandId(int id,
+                                               ui::Accelerator* accelerator) {
+  const ui::AcceleratorGtk* accelerator_gtk =
+      AcceleratorsGtk::GetInstance()->GetPrimaryAcceleratorForCommand(id);
+  if (accelerator_gtk)
+    *accelerator = *accelerator_gtk;
+  return !!accelerator_gtk;
+}
+
+void GlobalMenuBar::ExecuteCommand(int command_id) {
+  NOTREACHED();
+}
+
 void GlobalMenuBar::OnItemActivated(GtkWidget* sender) {
   if (block_activation_)
     return;
 
   int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sender), "command-id"));
   browser_->ExecuteCommandIfEnabled(id);
 }