Makes canceling 'bookmark all tabs' delete the folder. Or rather,...

chrome/browser/gtk/bookmark_editor_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_editor_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include "app/gfx/gtk_util.h"
 #include "app/l10n_util.h"
@@ skipping 22 matching lines @@
 // Preferred initial dimensions, in pixels, of the folder tree.
 static const int kTreeWidth = 300;
 static const int kTreeHeight = 150;
 
 }  // namespace
 
 // static
 void BookmarkEditor::Show(gfx::NativeWindow parent_hwnd,
                           Profile* profile,
                           const BookmarkNode* parent,
-                          const BookmarkNode* node,
+                          const EditDetails& details,
                           Configuration configuration,
                           Handler* handler) {
   DCHECK(profile);
   BookmarkEditorGtk* editor =
-      new BookmarkEditorGtk(parent_hwnd, profile, parent, node, configuration,
-                            handler);
+      new BookmarkEditorGtk(parent_hwnd, profile, parent, details,
+                            configuration, handler);
   editor->Show();
 }
 
 BookmarkEditorGtk::BookmarkEditorGtk(
     GtkWindow* window,
     Profile* profile,
     const BookmarkNode* parent,
-    const BookmarkNode* node,
+    const EditDetails& details,
     BookmarkEditor::Configuration configuration,
     BookmarkEditor::Handler* handler)
     : profile_(profile),
       dialog_(NULL),
       parent_(parent),
-      node_(node),
+      details_(details),
       running_menu_for_root_(false),
       show_tree_(configuration == SHOW_TREE),
       handler_(handler) {
   DCHECK(profile);
   Init(window);
 }
 
 BookmarkEditorGtk::~BookmarkEditorGtk() {
   // The tree model is deleted before the view. Reset the model otherwise the
   // tree will reference a deleted model.
@@ skipping 44 matching lines @@
   // |||+- GtkTreeViewColumn |name_column| -----------------------+|||
   // ||||                                                         ||||
   // ||||                                                         ||||
   // ||||                                                         ||||
   // ||||                                                         ||||
   // |||+---------------------------------------------------------+|||
   // ||+-----------------------------------------------------------+||
   // |+-------------------------------------------------------------+|
   // +---------------------------------------------------------------+
   //
-  // * The url and corresponding label are not shown if node_ is a folder.
+  // * The url and corresponding label are not shown if creating a new folder.
   GtkWidget* content_area = GTK_DIALOG(dialog_)->vbox;
   gtk_box_set_spacing(GTK_BOX(content_area), gtk_util::kContentAreaSpacing);
 
   GtkWidget* vbox = gtk_vbox_new(FALSE, 12);
 
   name_entry_ = gtk_entry_new();
-  gtk_entry_set_text(GTK_ENTRY(name_entry_),
-                     node_ ? WideToUTF8(node_->GetTitle()).c_str() : "");
+  std::string title;
+  if (details_.type == EditDetails::EXISTING_NODE) {
+    title = WideToUTF8(details_.existing_node->GetTitle());
+  } else if (details_.type == EditDetails::NEW_FOLDER) {
+    title = WideToUTF8(
+        l10n_util::GetString(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME));
+  }
+  gtk_entry_set_text(GTK_ENTRY(name_entry_), title.c_str());
   g_signal_connect(G_OBJECT(name_entry_), "changed",
                    G_CALLBACK(OnEntryChanged), this);
   gtk_entry_set_activates_default(GTK_ENTRY(name_entry_), TRUE);
 
   GtkWidget* table;
-  if (!IsEditingFolder()) {
+  if (details_.type != EditDetails::NEW_FOLDER) {
     url_entry_ = gtk_entry_new();
-    gtk_entry_set_text(GTK_ENTRY(url_entry_),
-                       node_ ? node_->GetURL().spec().c_str() : "");
+    std::string url_spec;
+    if (details_.type == EditDetails::EXISTING_NODE)
+      url_spec = details_.existing_node->GetURL().spec();
+    gtk_entry_set_text(GTK_ENTRY(url_entry_), url_spec.c_str());
     g_signal_connect(G_OBJECT(url_entry_), "changed",
                      G_CALLBACK(OnEntryChanged), this);
     gtk_entry_set_activates_default(GTK_ENTRY(url_entry_), TRUE);
     table = gtk_util::CreateLabeledControlsGroup(NULL,
         l10n_util::GetStringUTF8(IDS_BOOMARK_EDITOR_NAME_LABEL).c_str(),
         name_entry_,
         l10n_util::GetStringUTF8(IDS_BOOMARK_EDITOR_URL_LABEL).c_str(),
         url_entry_,
         NULL);
 
   } else {
     url_entry_ = NULL;
     table = gtk_util::CreateLabeledControlsGroup(NULL,
         l10n_util::GetStringUTF8(IDS_BOOMARK_EDITOR_NAME_LABEL).c_str(),
         name_entry_,
         NULL);
   }
 
   gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
 
   if (show_tree_) {
     GtkTreeIter selected_iter;
-    int64 selected_id = parent_ ? parent_->id() : 0;
-    const BookmarkNode* node_to_ignore = IsEditingFolder() ? node_ : NULL;
+    int64 selected_id = 0;
+    if (details_.type == EditDetails::EXISTING_NODE)
+      selected_id = details_.existing_node->GetParent()->id();
+    else if (parent_)
+      selected_id = parent_->id();
     tree_store_ = bookmark_utils::MakeFolderTreeStore();
-    bookmark_utils::AddToTreeStore(bb_model_, selected_id, node_to_ignore,
-                                   tree_store_, &selected_iter);
+    bookmark_utils::AddToTreeStore(bb_model_, selected_id, tree_store_,
+                                   &selected_iter);
     tree_view_ = bookmark_utils::MakeTreeViewForStore(tree_store_);
     gtk_widget_set_size_request(tree_view_, kTreeWidth, kTreeHeight);
     tree_selection_ = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view_));
 
     GtkTreePath* path = NULL;
     if (selected_id) {
       path = gtk_tree_model_get_path(GTK_TREE_MODEL(tree_store_),
                                      &selected_iter);
     } else {
       // We don't have a selected parent (Probably because we're making a new
@@ skipping 56 matching lines @@
 void BookmarkEditorGtk::BookmarkNodeAdded(BookmarkModel* model,
                                           const BookmarkNode* parent,
                                           int index) {
   Reset();
 }
 
 void BookmarkEditorGtk::BookmarkNodeRemoved(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index,
                                             const BookmarkNode* node) {
-  if ((node_ && node_->HasAncestor(node)) ||
+  if ((details_.type == EditDetails::EXISTING_NODE &&
+       details_.existing_node->HasAncestor(node)) ||
       (parent_ && parent_->HasAncestor(node))) {
     // The node, or its parent was removed. Close the dialog.
     Close();
   } else {
     Reset();
   }
 }
 
 void BookmarkEditorGtk::BookmarkNodeChildrenReordered(
     BookmarkModel* model, const BookmarkNode* node) {
@@ skipping 38 matching lines @@
   // We're going to apply edits to the bookmark bar model, which will call us
   // back. Normally when a structural edit occurs we reset the tree model.
   // We don't want to do that here, so we remove ourselves as an observer.
   bb_model_->RemoveObserver(this);
 
   GURL new_url(GetInputURL());
   std::wstring new_title(GetInputTitle());
 
   if (!show_tree_ || !selected_parent) {
     bookmark_utils::ApplyEditsWithNoGroupChange(
-        bb_model_, parent_, node_, new_title, new_url, handler_.get());
+        bb_model_, parent_, details_, new_title, new_url, handler_.get());
     return;
   }
 
   // Create the new groups and update the titles.
   const BookmarkNode* new_parent =
       bookmark_utils::CommitTreeStoreDifferencesBetween(
       bb_model_, tree_store_, selected_parent);
 
   if (!new_parent) {
     // Bookmarks must be parented.
     NOTREACHED();
     return;
   }
 
   bookmark_utils::ApplyEditsWithPossibleGroupChange(
-      bb_model_, new_parent, node_, new_title, new_url, handler_.get());
+      bb_model_, new_parent, details_, new_title, new_url, handler_.get());
 }
 
 void BookmarkEditorGtk::AddNewGroup(GtkTreeIter* parent, GtkTreeIter* child) {
   gtk_tree_store_append(tree_store_, child, parent);
   gtk_tree_store_set(
       tree_store_, child,
       bookmark_utils::FOLDER_ICON, GtkThemeProvider::GetFolderIcon(true),
       bookmark_utils::FOLDER_NAME,
           l10n_util::GetStringUTF8(IDS_BOOMARK_EDITOR_NEW_FOLDER_NAME).c_str(),
       bookmark_utils::ITEM_ID, static_cast<int64>(0),
       bookmark_utils::IS_EDITABLE, TRUE,
       -1);
 }
 
-bool BookmarkEditorGtk::IsEditingFolder() const {
-  return node_ && node_->is_folder();
-}
-
 // static
 void BookmarkEditorGtk::OnSelectionChanged(GtkTreeSelection* selection,
                                            BookmarkEditorGtk* dialog) {
   if (!gtk_tree_selection_get_selected(dialog->tree_selection_, NULL, NULL))
     gtk_widget_set_sensitive(dialog->new_folder_button_, FALSE);
   else
     gtk_widget_set_sensitive(dialog->new_folder_button_, TRUE);
 }
 
 // static
 void BookmarkEditorGtk::OnResponse(GtkDialog* dialog, int response_id,
                                    BookmarkEditorGtk* window) {
-  if (response_id == GTK_RESPONSE_ACCEPT) {
+  if (response_id == GTK_RESPONSE_ACCEPT)
     window->ApplyEdits();
-  }
 
   window->Close();
 }
 
 // static
 gboolean BookmarkEditorGtk::OnWindowDeleteEvent(
     GtkWidget* widget,
     GdkEvent* event,
     BookmarkEditorGtk* dialog) {
   dialog->Close();
 
   // Return true to prevent the gtk dialog from being destroyed. Close will
   // destroy it for us and the default gtk_dialog_delete_event_handler() will
   // force the destruction without us being able to stop it.
   return TRUE;
 }
 
 // static
 void BookmarkEditorGtk::OnWindowDestroy(GtkWidget* widget,
                                         BookmarkEditorGtk* dialog) {
   MessageLoop::current()->DeleteSoon(FROM_HERE, dialog);
 }
 
 // static
 void BookmarkEditorGtk::OnEntryChanged(GtkEditable* entry,
                                        BookmarkEditorGtk* dialog) {
   gboolean can_close = TRUE;
-  if (dialog->IsEditingFolder()) {
+  if (dialog->details_.type == EditDetails::NEW_FOLDER) {
     if (dialog->GetInputTitle().empty()) {
       gtk_widget_modify_base(dialog->name_entry_, GTK_STATE_NORMAL, &kErrorColor);

[Evan Stade, 2009/10/16 20:08:06]

80

       can_close = FALSE;
     } else {
       gtk_widget_modify_base(dialog->name_entry_, GTK_STATE_NORMAL, NULL);
     }
   } else {
     GURL url(dialog->GetInputURL());
     if (!url.is_valid()) {
       gtk_widget_modify_base(dialog->url_entry_, GTK_STATE_NORMAL, &kErrorColor);

[Evan Stade, 2009/10/16 20:08:06]

80

       can_close = FALSE;
     } else {
       gtk_widget_modify_base(dialog->url_entry_, GTK_STATE_NORMAL, NULL);
     }
   }
   gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog->dialog_),
                                     GTK_RESPONSE_ACCEPT, can_close);
 }
 
 // static
@@ skipping 17 matching lines @@
       GTK_TREE_MODEL(dialog->tree_store_), &new_item_iter);
   gtk_tree_view_expand_to_path(GTK_TREE_VIEW(dialog->tree_view_), path);
 
   // Make the folder name editable.
   gtk_tree_view_set_cursor(GTK_TREE_VIEW(dialog->tree_view_), path,
       gtk_tree_view_get_column(GTK_TREE_VIEW(dialog->tree_view_), 0),
       TRUE);
 
   gtk_tree_path_free(path);
 }