Add a context menu to the gtk task manager.

chrome/browser/gtk/task_manager_gtk.cc

 // Copyright (c) 2009 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/gtk/task_manager_gtk.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
+#include "chrome/browser/gtk/menu_gtk.h"
 #include "chrome/common/gtk_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // The task manager window default size.
 const int kDefaultWidth = 460;
 const int kDefaultHeight = 270;
 
@@ skipping 28 matching lines @@
     case IDS_TASK_MANAGER_NET_COLUMN:
       return kTaskManagerNetwork;
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       return kTaskManagerProcessID;
     default:
       NOTREACHED();
       return static_cast<TaskManagerColumn>(-1);
   }
 }
 
+int TaskManagerColumnIDToResourceID(int id) {
+  printf("id: %d\n", id);
+  switch (id) {
+    case kTaskManagerPage:
+      return IDS_TASK_MANAGER_PAGE_COLUMN;
+    case kTaskManagerPhysicalMem:
+      return IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN;
+    case kTaskManagerSharedMem:
+      return IDS_TASK_MANAGER_SHARED_MEM_COLUMN;
+    case kTaskManagerPrivateMem:
+      return IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN;
+    case kTaskManagerCPU:
+      return IDS_TASK_MANAGER_CPU_COLUMN;
+    case kTaskManagerNetwork:
+      return IDS_TASK_MANAGER_NET_COLUMN;
+    case kTaskManagerProcessID:
+      return IDS_TASK_MANAGER_PROCESS_ID_COLUMN;
+    default:
+      NOTREACHED();
+      return -1;
+  }
+}
+
 // Should be used for all gtk_tree_view functions that require a column index on
 // input.
 //
 // We need colid - 1 because the gtk_tree_view function is asking for the
 // column index, not the column id, and both kTaskManagerIcon and
 // kTaskManagerPage are in the same column index, so all column IDs are off by
 // one.
 int TreeViewColumnIndexFromID(TaskManagerColumn colid) {
   return colid - 1;
 }
 
 // Shows or hides a treeview column.
 void TreeViewColumnSetVisible(GtkWidget* treeview, TaskManagerColumn colid,
                               bool visible) {
   GtkTreeViewColumn* column = gtk_tree_view_get_column(
       GTK_TREE_VIEW(treeview), TreeViewColumnIndexFromID(colid));
   gtk_tree_view_column_set_visible(column, visible);
 }
 
+bool TreeViewColumnIsVisible(GtkWidget* treeview, TaskManagerColumn colid) {
+  GtkTreeViewColumn* column = gtk_tree_view_get_column(
+      GTK_TREE_VIEW(treeview), TreeViewColumnIndexFromID(colid));
+  return gtk_tree_view_column_get_visible(column);
+}
+
 void TreeViewInsertColumnWithPixbuf(GtkWidget* treeview, int resid) {
   int colid = TaskManagerResourceIDToColumnID(resid);
   GtkTreeViewColumn* column = gtk_tree_view_column_new();
   gtk_tree_view_column_set_title(column,
                                  l10n_util::GetStringUTF8(resid).c_str());
   GtkCellRenderer* image_renderer = gtk_cell_renderer_pixbuf_new();
   gtk_tree_view_column_pack_start(column, image_renderer, FALSE);
   gtk_tree_view_column_add_attribute(column, image_renderer,
                                      "pixbuf", kTaskManagerIcon);
   GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
@@ skipping 28 matching lines @@
   gint* indices = gtk_tree_path_get_indices(path);
   if (!indices) {
     NOTREACHED();
     return -1;
   }
   return indices[0];
 }
 
 }  // namespace
 
+class TaskManagerGtk::ContextMenuController : public MenuGtk::Delegate {
+ public:
+  explicit ContextMenuController(TaskManagerGtk* task_manager)
+      : task_manager_(task_manager) {
+    menu_.reset(new MenuGtk(this, false));
+    for (int i = kTaskManagerPage; i < kTaskManagerColumnCount - 1; i++) {
+      menu_->AppendCheckMenuItemWithLabel(
+          i, l10n_util::GetStringUTF8(TaskManagerColumnIDToResourceID(i)));
+    }
+
+    menu_->AppendCheckMenuItemWithLabel(kTaskManagerGoatsTeleported,
+                                        "Goats Teleported");
+  }
+
+  virtual ~ContextMenuController() {}
+
+  void RunMenu() {
+    menu_->PopupAsContext(gtk_get_current_event_time());
+  }
+
+  void Cancel() {
+    task_manager_ = NULL;
+    menu_->Cancel();
+  }
+
+ private:
+  // MenuGtk::Delegate implementation:
+  virtual bool IsCommandEnabled(int command_id) const {
+    if (!task_manager_)
+      return false;
+
+    return true;
+  }
+
+  virtual bool IsItemChecked(int command_id) const {
+    if (!task_manager_)
+      return false;
+
+    TaskManagerColumn colid = static_cast<TaskManagerColumn>(command_id);
+    return TreeViewColumnIsVisible(task_manager_->treeview_, colid);
+  }
+
+  virtual void ExecuteCommand(int command_id) {
+    if (!task_manager_)
+      return;
+
+    TaskManagerColumn colid = static_cast<TaskManagerColumn>(command_id);
+    bool visible = !TreeViewColumnIsVisible(task_manager_->treeview_, colid);
+    TreeViewColumnSetVisible(task_manager_->treeview_, colid, visible);
+  }
+
+  // The context menu.
+  scoped_ptr<MenuGtk> menu_;
+
+  // The TaskManager the context menu was brought up for. Set to NULL when the
+  // menu is canceled.
+  TaskManagerGtk* task_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(ContextMenuController);
+};
+
 TaskManagerGtk::TaskManagerGtk()
   : task_manager_(TaskManager::GetInstance()),
     model_(TaskManager::GetInstance()->model()),
     dialog_(NULL),
     treeview_(NULL),
     process_list_(NULL),
     process_count_(0) {
   Init();
 }
 
@@ skipping 82 matching lines @@
       NULL,
       GTK_DIALOG_NO_SEPARATOR,
       l10n_util::GetStringUTF8(IDS_TASK_MANAGER_KILL).c_str(),
       kTaskManagerResponseKill,
       NULL);
 
   gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog_)->vbox),
                       gtk_util::kContentAreaSpacing);
 
   g_signal_connect(G_OBJECT(dialog_), "response", G_CALLBACK(OnResponse), this);
+  g_signal_connect(G_OBJECT(dialog_), "button-release-event",
+                   G_CALLBACK(OnButtonReleaseEvent), this);
+  gtk_widget_add_events(dialog_,
+                        GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
 
   CreateTaskManagerTreeview();
   gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(treeview_), TRUE);
   gtk_tree_view_set_grid_lines(GTK_TREE_VIEW(treeview_),
                                GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
+  g_signal_connect(G_OBJECT(treeview_), "button-release-event",
+                   G_CALLBACK(OnButtonReleaseEvent), this);
+  gtk_widget_add_events(treeview_,
+                        GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
 
   // Hide some columns by default
   TreeViewColumnSetVisible(treeview_, kTaskManagerSharedMem, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerPrivateMem, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerProcessID, false);
   TreeViewColumnSetVisible(treeview_, kTaskManagerGoatsTeleported, false);
 
   // |selection| is owned by |treeview_|.
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
@@ skipping 111 matching lines @@
 
   GtkTreeModel* model;
   GList* paths = gtk_tree_selection_get_selected_rows(selection, &model);
   for (GList* item = paths; item; item = item->next) {
     int row = GetRowNumForPath(reinterpret_cast<GtkTreePath*>(item->data));
     task_manager_->KillProcess(row);
   }
   g_list_free(paths);
 }
 
+void TaskManagerGtk::ShowContextMenu() {
+  if (!menu_controller_.get())
+    menu_controller_.reset(new ContextMenuController(this));
+
+  menu_controller_->RunMenu();
+}
+
 // static
 void TaskManagerGtk::OnResponse(GtkDialog* dialog, gint response_id,
                                 TaskManagerGtk* task_manager) {
   if (response_id == GTK_RESPONSE_DELETE_EVENT) {
     instance_ = NULL;
     delete task_manager;
   } else if (response_id == kTaskManagerResponseKill) {
     task_manager->KillSelectedProcesses();
   }
 }
@@ skipping 11 matching lines @@
       selection_contains_browser_process = true;
       break;
     }
   }
   g_list_free(paths);
 
   bool sensitive = (paths != NULL) && !selection_contains_browser_process;
   gtk_dialog_set_response_sensitive(GTK_DIALOG(task_manager->dialog_),
                                     kTaskManagerResponseKill, sensitive);
 }
+
+// static
+gboolean TaskManagerGtk::OnButtonReleaseEvent(GtkWidget* widget,
+                                              GdkEventButton* event,
+                                              TaskManagerGtk* task_manager) {
+  // We don't want to open the context menu in the treeview.
+  if (widget == task_manager->treeview_)
+    return TRUE;
+
+  if (event->button == 3)
+    task_manager->ShowContextMenu();
+
+  return FALSE;
+}