Adds import/export of bookmarks to bookmarks.html file....

chrome/browser/views/bookmark_manager_view.cc

 // Copyright (c) 2006-2008 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/views/bookmark_manager_view.h"
 
 #include <algorithm>
 
 #include "base/gfx/skia_utils.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/bookmarks/bookmark_folder_tree_model.h"
+#include "chrome/browser/bookmarks/bookmark_html_writer.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_table_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/importer/importer.h"
 #include "chrome/browser/profile.h"
+#include "chrome/browser/user_metrics.h"
 #include "chrome/browser/views/bookmark_editor_view.h"
 #include "chrome/browser/views/bookmark_folder_tree_view.h"
 #include "chrome/browser/views/bookmark_table_view.h"
 #include "chrome/browser/views/standard_layout.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/gfx/color_utils.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/views/container_win.h"
 #include "chrome/views/grid_layout.h"
 #include "chrome/views/menu_button.h"
 #include "chrome/views/single_split_view.h"
 #include "chrome/views/window.h"
 
 #include "generated_resources.h"
 
 // If non-null, there is an open editor and this is the window it is contained
 // in it.
 static views::Window* open_window = NULL;
 // And this is the manager contained in it.
 static BookmarkManagerView* manager = NULL;
 
 // Delay, in ms, between when the user types and when we run the search.
 static const int kSearchDelayMS = 200;
 
+static const int kOrganizeMenuButtonID = 1;
+static const int kToolsMenuButtonID = 2;
+
+namespace {
+
+// Observer installed on the importer. When done importing the newly created
+// folder is selected in the bookmark manager.
+class ImportObserverImpl : public ImportObserver {
+ public:
+  explicit ImportObserverImpl(Profile* profile) : profile_(profile) {
+    BookmarkModel* model = profile->GetBookmarkModel();
+    initial_other_count_ = model->other_node()->GetChildCount();
+  }
+
+  virtual void ImportCanceled() {
+    delete this;
+  }
+
+  virtual void ImportComplete() {
+    // We aren't needed anymore.
+    MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+
+    BookmarkManagerView* manager = BookmarkManagerView::current();
+    if (!manager || manager->profile() != profile_)
+      return;
+
+    BookmarkModel* model = profile_->GetBookmarkModel();
+    int other_count = model->other_node()->GetChildCount();
+    if (other_count == initial_other_count_ + 1) {
+      BookmarkNode* imported_node =
+          model->other_node()->GetChild(initial_other_count_);
+      manager->SelectInTree(imported_node);
+      manager->ExpandAll(imported_node);
+    }
+  }
+
+ private:
+  Profile* profile_;
+  // Number of children in the other bookmarks folder at the time we were
+  // created.
+  int initial_other_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImportObserverImpl);
+};
+
+}  // namespace
+
 BookmarkManagerView::BookmarkManagerView(Profile* profile)
     : profile_(profile->GetOriginalProfile()),
       table_view_(NULL),
       tree_view_(NULL),
       search_factory_(this) {
   search_tf_ = new views::TextField();
   search_tf_->set_default_width_in_chars(40);
 
   table_view_ = new BookmarkTableView(profile_, NULL);
   table_view_->SetObserver(this);
   table_view_->SetContextMenuController(this);
 
   tree_view_ = new BookmarkFolderTreeView(profile_, NULL);
   tree_view_->SetController(this);
   tree_view_->SetContextMenuController(this);
 
   views::MenuButton* organize_menu_button = new views::MenuButton(
       l10n_util::GetString(IDS_BOOKMARK_MANAGER_ORGANIZE_MENU),
       this, true);
+  organize_menu_button->SetID(kOrganizeMenuButtonID);
+
+  views::MenuButton* tools_menu_button = new views::MenuButton(
+      l10n_util::GetString(IDS_BOOKMARK_MANAGER_TOOLS_MENU),
+      this, true);
+  tools_menu_button->SetID(kToolsMenuButtonID);
 
   split_view_ = new views::SingleSplitView(tree_view_, table_view_);
 
   views::GridLayout* layout = new views::GridLayout(this);
   SetLayoutManager(layout);
   const int top_id = 1;
   const int split_cs_id = 2;
-  layout->SetInsets(kPanelVertMargin, 0, 0, 0);
+  layout->SetInsets(2, 0, 0, 0);
   views::ColumnSet* column_set = layout->AddColumnSet(top_id);
   column_set->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER,
-                        1, views::GridLayout::USE_PREF, 0, 0);
+                        0, views::GridLayout::USE_PREF, 0, 0);
+  column_set->AddPaddingColumn(0, kRelatedControlHorizontalSpacing);
+  column_set->AddColumn(views::GridLayout::LEADING, views::GridLayout::CENTER,
+                        0, views::GridLayout::USE_PREF, 0, 0);
   column_set->AddPaddingColumn(1, kUnrelatedControlHorizontalSpacing);
   column_set->AddColumn(views::GridLayout::TRAILING, views::GridLayout::CENTER,
                         1, views::GridLayout::USE_PREF, 0, 0);
   column_set->AddPaddingColumn(0, kButtonHEdgeMargin);
 
   column_set = layout->AddColumnSet(split_cs_id);
   column_set->AddColumn(views::GridLayout::FILL, views::GridLayout::FILL, 1,
                         views::GridLayout::USE_PREF, 0, 0);
 
   layout->StartRow(0, top_id);
   layout->AddView(organize_menu_button);
+  layout->AddView(tools_menu_button);
   layout->AddView(search_tf_);
 
   layout->AddPaddingRow(0, kRelatedControlVerticalSpacing);
 
   layout->StartRow(1, split_cs_id);
   layout->AddView(split_view_);
 
   BookmarkModel* bookmark_model = profile_->GetBookmarkModel();
   if (!bookmark_model->IsLoaded())
     bookmark_model->AddObserver(this);
 }
 
 BookmarkManagerView::~BookmarkManagerView() {
+  if (select_file_dialog_.get())
+    select_file_dialog_->ListenerDestroyed();
+
   if (!GetBookmarkModel()->IsLoaded()) {
     GetBookmarkModel()->RemoveObserver(this);
   } else {
     // The models are deleted before the views. Make sure we set the models of
     // the views to NULL so that they aren't left holding a reference to a
     // deleted model.
     table_view_->SetModel(NULL);
     tree_view_->SetModel(NULL);
   }
   manager = NULL;
@@ skipping 50 matching lines @@
 
   if (node->is_url()) {
     int index = table_model_->IndexOfNode(node);
     if (index != -1)
       table_view_->Select(index);
     // TODO(sky): this doesn't work when invoked from add page.
     table_view_->RequestFocus();
   }
 }
 
+void BookmarkManagerView::ExpandAll(BookmarkNode* node) {
+  BookmarkNode* parent = node->is_url() ? node->GetParent() : node;
+  FolderNode* folder_node = tree_model_->GetFolderNodeForBookmarkNode(parent);
+  if (!folder_node) {
+    NOTREACHED();
+    return;
+  }
+  tree_view_->ExpandAll(folder_node);
+}
+
 BookmarkNode* BookmarkManagerView::GetSelectedFolder() {
   return tree_view_->GetSelectedBookmarkNode();
 }
 
 std::vector<BookmarkNode*> BookmarkManagerView::GetSelectedTableNodes() {
   std::vector<BookmarkNode*> nodes;
   for (views::TableView::iterator i = table_view_->SelectionBegin();
        i != table_view_->SelectionEnd(); ++i) {
     nodes.push_back(table_model_->GetNodeForRow(*i));
   }
@@ skipping 155 matching lines @@
            is_table ? BookmarkContextMenu::BOOKMARK_MANAGER_TABLE :
                       BookmarkContextMenu::BOOKMARK_MANAGER_TREE);
 }
 
 void BookmarkManagerView::RunMenu(views::View* source,
                                   const CPoint& pt,
                                   HWND hwnd) {
   // TODO(glen): when you change the buttons around and what not, futz with
   // this to make it look good. If you end up keeping padding numbers make them
   // constants.
-  ShowMenu(hwnd, pt.x - source->width() + 5, pt.y + 2,
-           BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU);
+  if (!GetBookmarkModel()->IsLoaded())
+    return;
+
+  if (source->GetID() == kOrganizeMenuButtonID) {
+    ShowMenu(hwnd, pt.x - source->width() + 5, pt.y + 2,
+             BookmarkContextMenu::BOOKMARK_MANAGER_ORGANIZE_MENU);
+  } else if (source->GetID() == kToolsMenuButtonID) {
+    ShowToolsMenu(hwnd, pt.x - source->width() + 5, pt.y + 2);
+  } else {
+    NOTREACHED();
+  }
+}
+
+void BookmarkManagerView::ExecuteCommand(int id) {
+  switch (id) {
+    case IDS_BOOKMARK_MANAGER_IMPORT_MENU:
+      UserMetrics::RecordAction(L"BookmarkManager_Import", profile_);
+      ShowImportBookmarksFileChooser();
+      break;
+
+    case IDS_BOOKMARK_MANAGER_EXPORT_MENU:
+      UserMetrics::RecordAction(L"BookmarkManager_Export", profile_);
+      ShowExportBookmarksFileChooser();
+      break;
+
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+void BookmarkManagerView::FileSelected(const std::wstring& path,
+                                       void* params) {
+  int id = reinterpret_cast<int>(params);
+  if (id == IDS_BOOKMARK_MANAGER_IMPORT_MENU) {
+    // ImporterHost is ref counted and will delete itself when done.
+    ImporterHost* host = new ImporterHost();
+    ProfileInfo profile_info;
+    profile_info.browser_type = BOOKMARKS_HTML;
+    profile_info.source_path = path;
+    StartImportingWithUI(GetContainer()->GetHWND(), FAVORITES, host,
+                         profile_info, profile_,
+                         new ImportObserverImpl(profile()), false);
+  } 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(), GetBookmarkModel(),
+          path);
+    }
+  } else {
+    NOTREACHED();
+  }
+}
+
+void BookmarkManagerView::FileSelectionCanceled(void* params) {
+  select_file_dialog_ = NULL;
 }
 
 BookmarkTableModel* BookmarkManagerView::CreateSearchTableModel() {
   std::wstring search_text = search_tf_->GetText();
   if (search_text.empty())
     return NULL;
   return BookmarkTableModel::CreateSearchTableModel(GetBookmarkModel(),
                                                     search_text);
 }
 
@@ skipping 95 matching lines @@
   } else {
     BookmarkNode* node = GetSelectedFolder();
     std::vector<BookmarkNode*> nodes;
     if (node)
       nodes.push_back(node);
     BookmarkContextMenu menu(GetContainer()->GetHWND(), profile_, NULL, NULL,
                              node, nodes, config);
     menu.RunMenuAt(x, y);
   }
 }
+
+void BookmarkManagerView::ShowToolsMenu(HWND host, int x, int y) {
+  views::MenuItemView menu(this);
+  menu.AppendMenuItemWithLabel(
+          IDS_BOOKMARK_MANAGER_IMPORT_MENU,
+          l10n_util::GetString(IDS_BOOKMARK_MANAGER_IMPORT_MENU));
+  menu.AppendMenuItemWithLabel(
+          IDS_BOOKMARK_MANAGER_EXPORT_MENU,
+          l10n_util::GetString(IDS_BOOKMARK_MANAGER_EXPORT_MENU));
+  menu.RunMenuAt(GetContainer()->GetHWND(), gfx::Rect(x, y, 0, 0),
+                 views::MenuItemView::TOPLEFT, true);
+}
+
+void BookmarkManagerView::ShowImportBookmarksFileChooser() {
+  if (select_file_dialog_.get())
+    select_file_dialog_->ListenerDestroyed();
+
+  // TODO(sky): need a textual description here once we can add new
+  // strings.
+  std::wstring filter_string(L"*.html\0*.html\0\0");
+  select_file_dialog_ = SelectFileDialog::Create(this);
+  select_file_dialog_->SelectFile(
+      SelectFileDialog::SELECT_OPEN_FILE, std::wstring(), std::wstring(),
+      filter_string, GetContainer()->GetHWND(),
+      reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_IMPORT_MENU));
+}
+
+void BookmarkManagerView::ShowExportBookmarksFileChooser() {
+  if (select_file_dialog_.get())
+    select_file_dialog_->ListenerDestroyed();
+
+  select_file_dialog_ = SelectFileDialog::Create(this);
+  select_file_dialog_->SelectFile(
+      SelectFileDialog::SELECT_SAVEAS_FILE, std::wstring(), std::wstring(),
+      std::wstring(), GetContainer()->GetHWND(),
+      reinterpret_cast<void*>(IDS_BOOKMARK_MANAGER_EXPORT_MENU));
+}