Bookmark manager polish:...

chrome/browser/gtk/bookmark_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/bookmark_manager_gtk.h"
 
 #include <vector>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/thread.h"
 #include "chrome/browser/bookmarks/bookmark_html_writer.h"
 #include "chrome/browser/bookmarks/bookmark_manager.h"
 #include "chrome/browser/bookmarks/bookmark_table_model.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/gtk/bookmark_tree_model.h"
 #include "chrome/browser/gtk/bookmark_utils_gtk.h"
 #include "chrome/browser/gtk/gtk_dnd_util.h"
 #include "chrome/browser/importer/importer.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/chrome_paths.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/generated_resources.h"
+#include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
 // Number of bookmarks shown in recently bookmarked.
 const int kRecentlyBookmarkedCount = 50;
 
 // IDs for the recently added and search nodes. These values assume that node
 // IDs will be strictly non-negative, which is an implementation detail of
 // BookmarkModel, so this is sort of a hack.
 const int kRecentID = -1;
 const int kSearchID = -2;
 
 // Padding between "Search:" and the entry field, in pixels.
 const int kSearchPadding = 5;
 
 // Time between a user action in the search box and when we perform the search.
 const int kSearchDelayMS = 200;
 
+// The default width of a column in the right tree view. Since we set the
+// columns to ellipsize, if we don't explicitly set a width they will be
+// wide enough to display only '...'. This will be overridden if the user
+// resizes the column.
+const int kDefaultColumnWidth = 200;
+
 // We only have one manager open at a time.
 BookmarkManagerGtk* manager = NULL;
 
 // Observer installed on the importer. When done importing the newly created
 // folder is selected in the bookmark manager.
 // This class is taken almost directly from BookmarkManagerView and should be
 // kept in sync with it.
 class ImportObserverImpl : public ImportObserver {
  public:
   explicit ImportObserverImpl(Profile* profile) : profile_(profile) {
@@ skipping 212 matching lines @@
       delaying_mousedown_(false) {
   InitWidgets();
   g_signal_connect(window_, "destroy",
                    G_CALLBACK(OnWindowDestroy), this);
 
   model_->AddObserver(this);
   if (model_->IsLoaded())
     Loaded(model_);
 
   gtk_widget_show_all(window_);
+  gtk_tree_view_columns_autosize(GTK_TREE_VIEW(right_tree_view_));
 }
 
 BookmarkManagerGtk::~BookmarkManagerGtk() {
+  SaveColumnConfiguration();
   model_->RemoveObserver(this);
 }
 
 void BookmarkManagerGtk::InitWidgets() {
   window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_title(GTK_WINDOW(window_),
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_TITLE).c_str());
-  // TODO(estade): use dimensions based on
-  // IDS_BOOKMARK_MANAGER_DIALOG_WIDTH_CHARS and
-  // IDS_BOOKMARK_MANAGER_DIALOG_HEIGHT_LINES.
-  gtk_window_set_default_size(GTK_WINDOW(window_), 640, 480);
+
+  // Set the default size of the bookmark manager.
+  // Windows has code to do this that uses ChromeFont; we could share it but
+  // since we don't plan to use it elsewhere it's probably not worth the effort.
+  PangoContext* context = gtk_widget_create_pango_context(window_);
+  PangoFontMetrics* metrics =
+      pango_context_get_metrics(context, window_->style->font_desc,
+                                pango_context_get_language(context));
+  double chars = 0;
+  StringToDouble(WideToUTF8(l10n_util::GetString(
+      IDS_BOOKMARK_MANAGER_DIALOG_WIDTH_CHARS)), &chars);
+  int width =
+      pango_font_metrics_get_approximate_char_width(metrics) *
+      static_cast<int>(chars) / PANGO_SCALE;
+  double lines = 0;
+  StringToDouble(WideToUTF8(l10n_util::GetString(
+      IDS_BOOKMARK_MANAGER_DIALOG_HEIGHT_LINES)), &lines);
+  int height =
+      (pango_font_metrics_get_ascent(metrics) +
+      pango_font_metrics_get_descent(metrics)) *
+      static_cast<int>(lines) / PANGO_SCALE;
+  gtk_window_set_default_size(GTK_WINDOW(window_), width, height);
+  pango_font_metrics_unref(metrics);
+  g_object_unref(context);
 
   // Build the organize and tools menus.
   organize_ = gtk_menu_item_new_with_label(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU).c_str());
 
   GtkWidget* import_item = gtk_menu_item_new_with_mnemonic(
       gtk_util::ConvertAcceleratorsFromWindowsStyle(
           l10n_util::GetStringUTF8(IDS_BOOKMARK_MANAGER_IMPORT_MENU)).c_str());
   g_signal_connect(import_item, "activate",
                    G_CALLBACK(OnImportItemActivated), this);
@@ skipping 27 matching lines @@
   GtkWidget* hbox = gtk_hbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(hbox), menu_bar, FALSE, FALSE, 0);
   gtk_box_pack_end(GTK_BOX(hbox), search_entry_, FALSE, FALSE, 0);
   gtk_box_pack_end(GTK_BOX(hbox), search_label, FALSE, FALSE, kSearchPadding);
 
   GtkWidget* left_pane = MakeLeftPane();
   GtkWidget* right_pane = MakeRightPane();
 
   GtkWidget* paned = gtk_hpaned_new();
   // Set the initial position of the pane divider.
-  // TODO(estade): we should set this to one third of the width of the window
-  // when it first shows (depending on the WM, this may or may not be the value
-  // we set below in gtk_window_set_size()).
-  gtk_paned_set_position(GTK_PANED(paned), 200);
+  gtk_paned_set_position(GTK_PANED(paned), width / 3);
   gtk_paned_pack1(GTK_PANED(paned), left_pane, FALSE, FALSE);
   gtk_paned_pack2(GTK_PANED(paned), right_pane, TRUE, FALSE);
 
   GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
   gtk_container_add(GTK_CONTAINER(window_), vbox);
 
   ResetOrganizeMenu(true);
 }
@@ skipping 41 matching lines @@
                                       GTK_SHADOW_ETCHED_IN);
   gtk_container_add(GTK_CONTAINER(scrolled), left_tree_view_);
 
   return scrolled;
 }
 
 GtkWidget* BookmarkManagerGtk::MakeRightPane() {
   right_store_ = gtk_list_store_new(RIGHT_PANE_NUM,
       GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
 
-  GtkTreeViewColumn* title_column = gtk_tree_view_column_new();
-  gtk_tree_view_column_set_title(title_column,
+  title_column_ = gtk_tree_view_column_new();
+  gtk_tree_view_column_set_title(title_column_,
       l10n_util::GetStringUTF8(IDS_BOOKMARK_TABLE_TITLE).c_str());
   GtkCellRenderer* image_renderer = gtk_cell_renderer_pixbuf_new();
-  gtk_tree_view_column_pack_start(title_column, image_renderer, FALSE);
-  gtk_tree_view_column_add_attribute(title_column, image_renderer,
+  gtk_tree_view_column_pack_start(title_column_, image_renderer, FALSE);
+  gtk_tree_view_column_add_attribute(title_column_, image_renderer,
                                      "pixbuf", RIGHT_PANE_PIXBUF);
   GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
-  gtk_tree_view_column_pack_start(title_column, text_renderer, TRUE);
-  gtk_tree_view_column_add_attribute(title_column, text_renderer,
+  g_object_set(text_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+  gtk_tree_view_column_pack_start(title_column_, text_renderer, TRUE);
+  gtk_tree_view_column_add_attribute(title_column_, text_renderer,
                                      "text", RIGHT_PANE_TITLE);
-  GtkTreeViewColumn* url_column = gtk_tree_view_column_new_with_attributes(
+
+  url_column_ = gtk_tree_view_column_new_with_attributes(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_TABLE_URL).c_str(),
-      gtk_cell_renderer_text_new(), "text", RIGHT_PANE_URL, NULL);
+      text_renderer, "text", RIGHT_PANE_URL, NULL);
+
   path_column_ = gtk_tree_view_column_new_with_attributes(
       l10n_util::GetStringUTF8(IDS_BOOKMARK_TABLE_PATH).c_str(),
-      gtk_cell_renderer_text_new(), "text", RIGHT_PANE_PATH, NULL);
+      text_renderer, "text", RIGHT_PANE_PATH, NULL);
+
+  SizeColumns();
 
   right_tree_view_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(right_store_));
   // Let |tree_view| own the store.
   g_object_unref(right_store_);
-  gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), title_column);
-  gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), url_column);
+  gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), title_column_);
+  gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), url_column_);
   gtk_tree_view_append_column(GTK_TREE_VIEW(right_tree_view_), path_column_);
   gtk_tree_selection_set_mode(right_selection(), GTK_SELECTION_MULTIPLE);
 
   g_signal_connect(right_tree_view_, "row-activated",
                    G_CALLBACK(OnRightTreeViewRowActivated), this);
   g_signal_connect(right_selection(), "changed",
                    G_CALLBACK(OnRightSelectionChanged), this);
   g_signal_connect(right_tree_view_, "focus-in-event",
                    G_CALLBACK(OnRightTreeViewFocusIn), this);
   g_signal_connect(right_tree_view_, "button-press-event",
@@ skipping 201 matching lines @@
   } else {
     GtkTreeIter sibling;
     gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(right_store_), &sibling,
                                   NULL, row - 1);
     gtk_list_store_insert_after(right_store_, &iter, &sibling);
   }
 
   SetRightSideColumnValues(row, &iter);
 }
 
+void BookmarkManagerGtk::SizeColumn(GtkTreeViewColumn* column,
+                                    const wchar_t* prefname) {
+  gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+  gtk_tree_view_column_set_resizable(column, TRUE);
+
+  PrefService* prefs = profile_->GetPrefs();
+  if (!prefs)
+    return;
+
+  int width = prefs->GetInteger(prefname);
+  if (width <= 0)
+    width = kDefaultColumnWidth;
+  gtk_tree_view_column_set_fixed_width(column, width);
+}
+
+void BookmarkManagerGtk::SizeColumns() {
+  SizeColumn(title_column_, prefs::kBookmarkTableNameWidth1);
+  SizeColumn(url_column_, prefs::kBookmarkTableURLWidth1);
+  SizeColumn(path_column_, prefs::kBookmarkTablePathWidth);
+}
+
+void BookmarkManagerGtk::SaveColumnConfiguration() {
+  PrefService* prefs = profile_->GetPrefs();
+  if (!prefs)
+    return;
+
+  prefs->SetInteger(prefs::kBookmarkTableNameWidth1,
+                    gtk_tree_view_column_get_width(title_column_));
+  prefs->SetInteger(prefs::kBookmarkTableURLWidth1,
+                    gtk_tree_view_column_get_width(url_column_));
+  prefs->SetInteger(prefs::kBookmarkTablePathWidth,
+                    gtk_tree_view_column_get_width(path_column_));
+}
+
 bool BookmarkManagerGtk::RecursiveFind(GtkTreeModel* model, GtkTreeIter* iter,
                                        int target) {
   GValue value = { 0, };
   bool left = model == GTK_TREE_MODEL(left_store_);
   if (left) {
     if (iter->stamp == 0)
       gtk_tree_model_get_iter_first(GTK_TREE_MODEL(left_store_), iter);
     gtk_tree_model_get_value(model, iter, bookmark_utils::ITEM_ID, &value);
   }
   else {
@@ skipping 435 matching lines @@
   } else if (id == IDS_BOOKMARK_MANAGER_EXPORT_MENU) {
     if (g_browser_process->io_thread()) {
       bookmark_html_writer::WriteBookmarks(
           g_browser_process->io_thread()->message_loop(), model_,
           path.ToWStringHack());
     }
   } else {
     NOTREACHED();
   }
 }