Linux: set the initial size of the "Page" column in the task manager to fit the dialog.

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 "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_chrome_link_button.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/chromium_strings.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // The task manager window default size.
 const int kDefaultWidth = 460;
@@ skipping 93 matching lines @@
   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();
   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);
 }
 
 // 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);
 }
 
 // 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());
 }
 
-// Get the row number corresponding to |path|.
-gint GetRowNumForPath(GtkTreePath* path) {
-  gint* indices = gtk_tree_path_get_indices(path);
-  if (!indices) {
-    NOTREACHED();
-    return -1;
-  }
-  return indices[0];
+// 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++) {
@@ skipping 211 matching lines @@
 
   gtk_container_add(GTK_CONTAINER(scrolled), treeview_);
 
   SetInitialDialogSize();
   gtk_widget_show_all(dialog_);
 
   model_->AddObserver(this);
 }
 
 void TaskManagerGtk::SetInitialDialogSize() {
+  // Hook up to the realize event so we can size the page column to the
+  // size of the leftover space after packing the other columns.
+  g_signal_connect(G_OBJECT(treeview_), "realize",
+                   G_CALLBACK(OnTreeViewRealize), this);
   // If we previously saved the dialog's bounds, use them.
   if (g_browser_process->local_state()) {
     const DictionaryValue* placement_pref =
         g_browser_process->local_state()->GetDictionary(
             prefs::kTaskManagerWindowPlacement);
     int top = 0, left = 0, bottom = 1, right = 1;
     if (placement_pref &&
         placement_pref->GetInteger(L"top", &top) &&
         placement_pref->GetInteger(L"left", &left) &&
         placement_pref->GetInteger(L"bottom", &bottom) &&
@@ skipping 120 matching lines @@
   g_object_unref(icon);
 }
 
 void TaskManagerGtk::KillSelectedProcesses() {
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
 
   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));
+    int row = gtk_tree::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();
 }
 
 void TaskManagerGtk::ActivateFocusedTab() {
   GtkTreeSelection* selection = gtk_tree_view_get_selection(
       GTK_TREE_VIEW(treeview_));
 
   // If the user has just double clicked, only one item is selected.
   GtkTreeModel* model;
   GList* selected = gtk_tree_selection_get_selected_rows(selection, &model);
   if (selected) {
-    int row = GetRowNumForPath(reinterpret_cast<GtkTreePath*>(selected->data));
+    int row = gtk_tree::GetRowNumForPath(
+        reinterpret_cast<GtkTreePath*>(selected->data));
     task_manager_->ActivateProcess(row);
   }
 }
 
 void TaskManagerGtk::OnLinkActivated() {
   Browser* browser = BrowserList::GetLastActive();
   DCHECK(browser);
   browser->OpenURL(GURL("about:memory"), GURL(), NEW_FOREGROUND_TAB,
                    PageTransition::LINK);
   // In case the browser window is minimzed, show it. If this is an application
@@ skipping 33 matching lines @@
     instance_ = NULL;
     delete task_manager;
   } else if (response_id == kTaskManagerResponseKill) {
     task_manager->KillSelectedProcesses();
   } else if (response_id == kTaskManagerAboutMemoryLink) {
     task_manager->OnLinkActivated();
   }
 }
 
 // static
+void TaskManagerGtk::OnTreeViewRealize(GtkTreeView* treeview,
+                                       TaskManagerGtk* task_manager) {
+  GtkTreeViewColumn* column = gtk_tree_view_get_column(
+      GTK_TREE_VIEW(task_manager->treeview_),
+      TreeViewColumnIndexFromID(kTaskManagerPage));
+  gint width = gtk_tree_view_column_get_width(column);
+  // Turn expanding back off to make resizing columns behave sanely.
+  gtk_tree_view_column_set_expand(column, FALSE);
+  // Subtract 1 to work around some sort of fencepost error in GTK: without
+  // it, a horizontal scroll bar with one pixel of wiggle room will appear.
+  TreeViewColumnSetWidth(column, width - 1);
+}
+
+// static
 void TaskManagerGtk::OnSelectionChanged(GtkTreeSelection* selection,
                                         TaskManagerGtk* task_manager) {
   bool selection_contains_browser_process = false;
 
   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));
+    int row = gtk_tree::GetRowNumForPath(
+        reinterpret_cast<GtkTreePath*>(item->data));
     if (task_manager->task_manager_->IsBrowserProcess(row)) {
       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);
@@ skipping 32 matching lines @@
   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);
     gtk_widget_destroy(task_manager->dialog_);
   }
 
   return TRUE;
 }