Gtk: Allow all columns in task manager to be sortable.

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 <gdk/gdkkeysyms.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/gfx/gtk_util.h"
 #include "base/logging.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/gtk_chrome_link_button.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/menu_gtk.h"
 #include "chrome/common/gtk_tree.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/app_resources.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;
 
 // The resource id for the 'End process' button.
 const gint kTaskManagerResponseKill = 1;
 
@@ skipping 22 matching lines @@
     case IDS_TASK_MANAGER_SHARED_MEM_COLUMN:
       return kTaskManagerSharedMem;
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:
       return kTaskManagerPrivateMem;
     case IDS_TASK_MANAGER_CPU_COLUMN:
       return kTaskManagerCPU;
     case IDS_TASK_MANAGER_NET_COLUMN:
       return kTaskManagerNetwork;
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:
       return kTaskManagerProcessID;
+    case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:
+      return kTaskManagerGoatsTeleported;
     default:
       NOTREACHED();
       return static_cast<TaskManagerColumn>(-1);
   }
 }
 
 int TaskManagerColumnIDToResourceID(int 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;
+    case kTaskManagerGoatsTeleported:
+      return IDS_TASK_MANAGER_GOATS_TELEPORTED_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
@@ skipping 27 matching lines @@
   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();
   gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
   gtk_tree_view_column_add_attribute(column, text_renderer, "text", colid);
   gtk_tree_view_column_set_resizable(column, TRUE);
   // This is temporary: we'll turn expanding off after getting the size.
   gtk_tree_view_column_set_expand(column, TRUE);
   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
+  gtk_tree_view_column_set_sort_column_id(column, colid);
 }
 
 // Inserts a column with a column id of |colid| and |name|.
 void TreeViewInsertColumnWithName(GtkWidget* treeview,
                                   TaskManagerColumn colid, const char* name) {
   GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
   gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1,
                                               name, renderer,
                                               "text", colid,
                                               NULL);
   GtkTreeViewColumn* column = gtk_tree_view_get_column(
       GTK_TREE_VIEW(treeview), TreeViewColumnIndexFromID(colid));
   gtk_tree_view_column_set_resizable(column, TRUE);
+  gtk_tree_view_column_set_sort_column_id(column, colid);
 }
 
 // Loads the column name from |resid| and uses the corresponding
 // TaskManagerColumn value as the column id to insert into the treeview.
 void TreeViewInsertColumn(GtkWidget* treeview, int resid) {
   TreeViewInsertColumnWithName(treeview, TaskManagerResourceIDToColumnID(resid),
                                l10n_util::GetStringUTF8(resid).c_str());
 }
 
 // Set the current width of the column without forcing a minimum width as
 // gtk_tree_view_column_set_fixed_width() would. This would basically be
 // gtk_tree_view_column_set_width() except that there is no such function.
 void TreeViewColumnSetWidth(GtkTreeViewColumn* column, gint width) {
   column->width = width;
   column->resized_width = width;
   column->use_resized_width = TRUE;
   // Needed for use_resized_width to be effective.
   gtk_widget_queue_resize(column->tree_view);
 }
 
 }  // 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++) {
+    for (int i = kTaskManagerPage; i < kTaskManagerColumnCount; 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;
@@ skipping 183 matching lines @@
 
   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-press-event",
                    G_CALLBACK(OnButtonPressEvent), 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_));
   gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
   g_signal_connect(G_OBJECT(selection), "changed",
                    G_CALLBACK(OnSelectionChanged), this);
 
   gtk_container_add(GTK_CONTAINER(scrolled), treeview_);
 
   SetInitialDialogSize();
@@ skipping 35 matching lines @@
   accel_group_ = gtk_accel_group_new();
   gtk_window_add_accel_group(GTK_WINDOW(dialog_), accel_group_);
 
   gtk_accel_group_connect(accel_group_,
                           GDK_w, GDK_CONTROL_MASK, GtkAccelFlags(0),
                           g_cclosure_new(G_CALLBACK(OnGtkAccelerator),
                                          this, NULL));
 }
 
 void TaskManagerGtk::CreateTaskManagerTreeview() {
-  treeview_ = gtk_tree_view_new();
+  process_list_ = gtk_list_store_new(kTaskManagerColumnCount,
+      GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
+      G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
+      G_TYPE_STRING);
 
+  // Support sorting on all columns.
+  process_list_sort_ = gtk_tree_model_sort_new_with_model(
+      GTK_TREE_MODEL(process_list_));
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerPage,
+                                  ComparePage, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerPhysicalMem,
+                                  ComparePhysicalMemory, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerSharedMem,
+                                  CompareSharedMemory, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerPrivateMem,
+                                  ComparePrivateMemory, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerCPU,
+                                  CompareCPU, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerNetwork,
+                                  CompareNetwork, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerProcessID,
+                                  CompareProcessID, this, NULL);
+  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(process_list_sort_),
+                                  kTaskManagerGoatsTeleported,
+                                  CompareGoatsTeleported, this, NULL);
+  treeview_ = gtk_tree_view_new_with_model(process_list_sort_);
+
+  // Insert all the columns.
   TreeViewInsertColumnWithPixbuf(treeview_, IDS_TASK_MANAGER_PAGE_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_SHARED_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_CPU_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_NET_COLUMN);
   TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_PROCESS_ID_COLUMN);
+  TreeViewInsertColumn(treeview_, IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN);
 
-  TreeViewInsertColumnWithName(treeview_, kTaskManagerGoatsTeleported,
-                               "Goats Teleported");
-
-  process_list_ = gtk_list_store_new(kTaskManagerColumnCount,
-      GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
-      G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
-      G_TYPE_STRING);
-
-  gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_),
-                          GTK_TREE_MODEL(process_list_));
+  // Hide some columns by default.
+  TreeViewColumnSetVisible(treeview_, kTaskManagerSharedMem, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerPrivateMem, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerProcessID, false);
+  TreeViewColumnSetVisible(treeview_, kTaskManagerGoatsTeleported, false);
+  
   g_object_unref(process_list_);
+  g_object_unref(process_list_sort_);
 }
 
 std::string TaskManagerGtk::GetModelText(int row, int col_id) {
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN:  // Process
       return WideToUTF8(model_->GetResourceTitle(row));
 
     case IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN:  // Memory
       if (!model_->IsResourceFirstInGroup(row))
         return std::string();
@@ skipping 15 matching lines @@
       return WideToUTF8(model_->GetResourceCPUUsage(row));
 
     case IDS_TASK_MANAGER_NET_COLUMN:  // Net
       return WideToUTF8(model_->GetResourceNetworkUsage(row));
 
     case IDS_TASK_MANAGER_PROCESS_ID_COLUMN:  // Process ID
       if (!model_->IsResourceFirstInGroup(row))
         return std::string();
       return WideToUTF8(model_->GetResourceProcessId(row));
 
-    case kTaskManagerGoatsTeleported:  // Goats Teleported!
+    case IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN:  // Goats Teleported!
       return WideToUTF8(model_->GetResourceGoatsTeleported(row));
 
     default:
       return WideToUTF8(model_->GetResourceStatsValue(row, col_id));
   }
 }
 
 GdkPixbuf* TaskManagerGtk::GetModelIcon(int row) {
   SkBitmap icon = model_->GetResourceIcon(row);
   if (icon.pixelRef() ==
@@ skipping 10 matching lines @@
   GdkPixbuf* icon = GetModelIcon(row);
   std::string page = GetModelText(row, IDS_TASK_MANAGER_PAGE_COLUMN);
   std::string phys_mem = GetModelText(
       row, IDS_TASK_MANAGER_PHYSICAL_MEM_COLUMN);
   std::string shared_mem = GetModelText(
       row, IDS_TASK_MANAGER_SHARED_MEM_COLUMN);
   std::string priv_mem = GetModelText(row, IDS_TASK_MANAGER_PRIVATE_MEM_COLUMN);
   std::string cpu = GetModelText(row, IDS_TASK_MANAGER_CPU_COLUMN);
   std::string net = GetModelText(row, IDS_TASK_MANAGER_NET_COLUMN);
   std::string procid = GetModelText(row, IDS_TASK_MANAGER_PROCESS_ID_COLUMN);
-  std::string goats = GetModelText(row, kTaskManagerGoatsTeleported);
+  std::string goats = GetModelText(
+      row, IDS_TASK_MANAGER_GOATS_TELEPORTED_COLUMN);
   gtk_list_store_set(process_list_, iter,
                      kTaskManagerIcon, icon,
                      kTaskManagerPage, page.c_str(),
                      kTaskManagerPhysicalMem, phys_mem.c_str(),
                      kTaskManagerSharedMem, shared_mem.c_str(),
                      kTaskManagerPrivateMem, priv_mem.c_str(),
                      kTaskManagerCPU, cpu.c_str(),
                      kTaskManagerNetwork, net.c_str(),
                      kTaskManagerProcessID, procid.c_str(),
                      kTaskManagerGoatsTeleported, goats.c_str(),
@@ skipping 46 matching lines @@
   // tabbed browser window. Currently, |browser| is pointing to the application,
   // popup window. Therefore, we have to retrieve the last active tab again,
   // since a new window has been used.
   if (browser->type() & Browser::TYPE_APP_POPUP) {
     browser = BrowserList::GetLastActive();
     DCHECK(browser);
   }
   browser->window()->Show();
 }
 
+gint TaskManagerGtk::CompareImpl(GtkTreeModel* model, GtkTreeIter* a,
+                                 GtkTreeIter* b, int id) {
+  int row1 = gtk_tree::GetRowNumForIter(model, a);
+  int row2 = gtk_tree::GetRowNumForIter(model, b);
+  return model_->CompareValues(row1, row2, id);
+}
+
 // static
 void TaskManagerGtk::OnResponse(GtkDialog* dialog, gint response_id,
                                 TaskManagerGtk* task_manager) {
   if (response_id == GTK_RESPONSE_DELETE_EVENT) {
     // Store the dialog's size so we can restore it the next time it's opened.
     if (g_browser_process->local_state()) {
       gint x = 0, y = 0, width = 1, height = 1;
       gtk_window_get_position(GTK_WINDOW(dialog), &x, &y);
       gtk_window_get_size(GTK_WINDOW(dialog), &width, &height);
 
@@ skipping 103 matching lines @@
                                           TaskManagerGtk* task_manager) {
   if (keyval == GDK_w && modifier == GDK_CONTROL_MASK) {
     // The GTK_RESPONSE_DELETE_EVENT response must be sent before the widget
     // is destroyed.  The deleted object will receive gtk signals otherwise.
     gtk_dialog_response(GTK_DIALOG(task_manager->dialog_),
                         GTK_RESPONSE_DELETE_EVENT);
   }
 
   return TRUE;
 }