Finish the gtk search engine manager.

chrome/browser/gtk/keyword_editor_view.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/keyword_editor_view.h"
 
 #include "app/l10n_util.h"
+#include "base/gfx/gtk_util.h"
 #include "chrome/browser/gtk/edit_search_engine_dialog.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/metrics/user_metrics.h"
+#include "chrome/browser/search_engines/keyword_editor_controller.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_model.h"
+#include "chrome/browser/search_engines/template_url_table_model.h"
 #include "chrome/common/gtk_util.h"
 #include "grit/generated_resources.h"
 
 namespace {
 
 // Initial size for dialog.
 const int kDialogDefaultWidth = 450;
 const int kDialogDefaultHeight = 450;
 
+// How many rows should be added to an index into the |table_model_| to get the
+// corresponding row in |list_store_|
+const int kFirstGroupRowOffset = 2;
+const int kSecondGroupRowOffset = 5;
+
 // Column ids for |list_store_|.
 enum {
   COL_FAVICON,
   COL_TITLE,
   COL_KEYWORD,
+  COL_IS_HEADER,
+  COL_IS_SEPARATOR,
+  COL_WEIGHT,
+  COL_WEIGHT_SET,
   COL_COUNT,
 };
 
 KeywordEditorView* instance_ = NULL;
 
 }
 
 // static
 void KeywordEditorView::Show(Profile* profile) {
   DCHECK(profile);
   if (!profile->GetTemplateURLModel())
     return;
 
   // If there's already an existing editor window, activate it.
   if (instance_) {
     gtk_window_present(GTK_WINDOW(instance_->dialog_));
   } else {
     instance_ = new KeywordEditorView(profile);
   }
 }
 
 void KeywordEditorView::OnEditedKeyword(const TemplateURL* template_url,
                                         const std::wstring& title,
                                         const std::wstring& keyword,
                                         const std::wstring& url) {
-  NOTIMPLEMENTED();
+  if (template_url) {
+    controller_->ModifyTemplateURL(template_url, title, keyword, url);
+
+    // Force the make default button to update.
+    EnableControls();
+  } else {
+    SelectModelRow(controller_->AddTemplateURL(title, keyword, url));
+  }
 }
 
 KeywordEditorView::~KeywordEditorView() {
-  url_model_->RemoveObserver(this);
+  controller_->url_model()->RemoveObserver(this);
 }
 
 KeywordEditorView::KeywordEditorView(Profile* profile)
     : profile_(profile),
-      url_model_(profile->GetTemplateURLModel()) {
+      controller_(new KeywordEditorController(profile)),
+      table_model_(controller_->table_model()) {
   Init();
 }
 
 void KeywordEditorView::Init() {
-  DCHECK(url_model_);
-  url_model_->Load();
-  url_model_->AddObserver(this);
-
   dialog_ = gtk_dialog_new_with_buttons(
       l10n_util::GetStringUTF8(IDS_SEARCH_ENGINES_EDITOR_WINDOW_TITLE).c_str(),
       NULL,
       // Non-modal.
       GTK_DIALOG_NO_SEPARATOR,
       GTK_STOCK_CLOSE,
       GTK_RESPONSE_CLOSE,
       NULL);
 
   gtk_window_set_default_size(GTK_WINDOW(dialog_), kDialogDefaultWidth,
                               kDialogDefaultHeight);
   gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog_)->vbox),
                       gtk_util::kContentAreaSpacing);
 
   GtkWidget* hbox = gtk_hbox_new(FALSE, gtk_util::kControlSpacing);
   gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog_)->vbox), hbox);
 
   GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window),
                                  GTK_POLICY_AUTOMATIC,
                                  GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window),
                                       GTK_SHADOW_ETCHED_IN);
   gtk_box_pack_start(GTK_BOX(hbox), scroll_window, TRUE, TRUE, 0);
 
   list_store_ = gtk_list_store_new(COL_COUNT,
                                    GDK_TYPE_PIXBUF,
                                    G_TYPE_STRING,
-                                   G_TYPE_STRING);
+                                   G_TYPE_STRING,
+                                   G_TYPE_BOOLEAN,
+                                   G_TYPE_BOOLEAN,
+                                   G_TYPE_INT,
+                                   G_TYPE_BOOLEAN);
   tree_ = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store_));
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_), TRUE);
+  gtk_tree_view_set_row_separator_func(GTK_TREE_VIEW(tree_),
+                                       OnCheckRowIsSeparator,
+                                       NULL, NULL);
+  g_signal_connect(G_OBJECT(tree_), "row-activated",
+                   G_CALLBACK(OnRowActivated), this);
   gtk_container_add(GTK_CONTAINER(scroll_window), tree_);
 
   GtkTreeViewColumn* title_column = gtk_tree_view_column_new();
   GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
   gtk_tree_view_column_pack_start(title_column, pixbuf_renderer, FALSE);
   gtk_tree_view_column_add_attribute(title_column, pixbuf_renderer, "pixbuf",
                                      COL_FAVICON);
   GtkCellRenderer* title_renderer = gtk_cell_renderer_text_new();
   gtk_tree_view_column_pack_start(title_column, title_renderer, TRUE);
   gtk_tree_view_column_add_attribute(title_column, title_renderer, "text",
                                      COL_TITLE);
+  gtk_tree_view_column_add_attribute(title_column, title_renderer, "weight",
+                                     COL_WEIGHT);
+  gtk_tree_view_column_add_attribute(title_column, title_renderer, "weight-set",
+                                     COL_WEIGHT_SET);
   gtk_tree_view_column_set_title(
       title_column, l10n_util::GetStringUTF8(
           IDS_SEARCH_ENGINES_EDITOR_DESCRIPTION_COLUMN).c_str());
   gtk_tree_view_append_column(GTK_TREE_VIEW(tree_), title_column);
 
   GtkTreeViewColumn* keyword_column = gtk_tree_view_column_new_with_attributes(
       l10n_util::GetStringUTF8(
           IDS_SEARCH_ENGINES_EDITOR_KEYWORD_COLUMN).c_str(),
       gtk_cell_renderer_text_new(),
       "text", COL_KEYWORD,
       NULL);
   gtk_tree_view_append_column(GTK_TREE_VIEW(tree_), keyword_column);
 
   selection_ = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_));
   gtk_tree_selection_set_mode(selection_, GTK_SELECTION_SINGLE);
+  gtk_tree_selection_set_select_function(selection_, OnSelectionFilter,
+                                         NULL, NULL);
   g_signal_connect(G_OBJECT(selection_), "changed",
                    G_CALLBACK(OnSelectionChanged), this);
 
   GtkWidget* button_box = gtk_vbox_new(FALSE, gtk_util::kControlSpacing);
   gtk_box_pack_start(GTK_BOX(hbox), button_box, FALSE, FALSE, 0);
 
   add_button_ = gtk_button_new_with_label(
       l10n_util::GetStringUTF8(IDS_SEARCH_ENGINES_EDITOR_NEW_BUTTON).c_str());
   g_signal_connect(G_OBJECT(add_button_), "clicked",
                    G_CALLBACK(OnAddButtonClicked), this);
@@ skipping 13 matching lines @@
   gtk_box_pack_start(GTK_BOX(button_box), remove_button_, FALSE, FALSE, 0);
 
   make_default_button_ = gtk_button_new_with_label(
       l10n_util::GetStringUTF8(
           IDS_SEARCH_ENGINES_EDITOR_MAKE_DEFAULT_BUTTON).c_str());
   g_signal_connect(G_OBJECT(make_default_button_), "clicked",
                    G_CALLBACK(OnMakeDefaultButtonClicked), this);
   gtk_box_pack_start(GTK_BOX(button_box), make_default_button_, FALSE, FALSE,
                      0);
 
+  controller_->url_model()->AddObserver(this);
+  table_model_->SetObserver(this);
+  table_model_->Reload();
+
   EnableControls();
 
   gtk_widget_show_all(dialog_);
 
   g_signal_connect(dialog_, "response", G_CALLBACK(OnResponse), this);
   g_signal_connect(dialog_, "destroy", G_CALLBACK(OnWindowDestroy), this);
 }
 
 void KeywordEditorView::EnableControls() {
-  bool enable = gtk_tree_selection_count_selected_rows(selection_) == 1;
+  bool can_edit = false;
   bool can_make_default = false;
   bool can_remove = false;
-  // TODO(mattm)
-  gtk_widget_set_sensitive(add_button_, url_model_->loaded());
-  gtk_widget_set_sensitive(edit_button_, enable);
-  gtk_widget_set_sensitive(remove_button_, can_make_default);
-  gtk_widget_set_sensitive(make_default_button_, can_remove);
+  int model_row = GetSelectedModelRow();
+  if (model_row != -1) {
+    can_edit = true;
+    const TemplateURL* selected_url = controller_->GetTemplateURL(model_row);
+    can_make_default = controller_->CanMakeDefault(selected_url);
+    can_remove = controller_->CanRemove(selected_url);
+  }
+  gtk_widget_set_sensitive(add_button_, controller_->loaded());
+  gtk_widget_set_sensitive(edit_button_, can_edit);
+  gtk_widget_set_sensitive(remove_button_, can_remove);
+  gtk_widget_set_sensitive(make_default_button_, can_make_default);
+}
+
+void KeywordEditorView::SetColumnValues(int model_row, GtkTreeIter* iter) {
+  SkBitmap bitmap = table_model_->GetIcon(model_row);
+  GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&bitmap);
+  gtk_list_store_set(
+      list_store_, iter,
+      COL_FAVICON, pixbuf,
+      // Dunno why, even with COL_WEIGHT_SET to FALSE here, the weight still
+      // has an effect.  So we just set it to normal.
+      COL_WEIGHT, PANGO_WEIGHT_NORMAL,
+      COL_WEIGHT_SET, TRUE,
+      COL_TITLE, WideToUTF8(table_model_->GetText(
+          model_row, IDS_SEARCH_ENGINES_EDITOR_DESCRIPTION_COLUMN)).c_str(),
+      COL_KEYWORD, WideToUTF8(table_model_->GetText(
+          model_row, IDS_SEARCH_ENGINES_EDITOR_KEYWORD_COLUMN)).c_str(),
+      -1);
+}
+
+int KeywordEditorView::GetListStoreRowForModelRow(int model_row) const {
+  if (model_row < model_second_group_index_)
+    return model_row + kFirstGroupRowOffset;
+  else
+    return model_row + kSecondGroupRowOffset;
+}
+
+int KeywordEditorView::GetModelRowForPath(GtkTreePath* path) const {
+  gint* indices = gtk_tree_path_get_indices(path);
+  if (!indices) {
+    NOTREACHED();
+    return -1;
+  }
+  if (indices[0] >= model_second_group_index_ + kSecondGroupRowOffset)
+    return indices[0] - kSecondGroupRowOffset;
+  return indices[0] - kFirstGroupRowOffset;
+}
+
+int KeywordEditorView::GetModelRowForIter(GtkTreeIter* iter) const {
+  GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store_),
+                                              iter);
+  int model_row = GetModelRowForPath(path);
+  gtk_tree_path_free(path);
+  return model_row;
+}
+
+int KeywordEditorView::GetSelectedModelRow() const {
+  GtkTreeIter iter;
+  if (!gtk_tree_selection_get_selected(selection_, NULL, &iter))
+    return -1;
+  return GetModelRowForIter(&iter);
+}
+
+void KeywordEditorView::SelectModelRow(int model_row) {
+  int row = GetListStoreRowForModelRow(model_row);
+  GtkTreeIter iter;
+  if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_),
+                                     &iter, NULL, row)) {
+    NOTREACHED();
+    return;
+  }
+  GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(list_store_),
+                                              &iter);
+  gtk_tree_view_set_cursor(GTK_TREE_VIEW(tree_), path, NULL, FALSE);
+  gtk_tree_path_free(path);
+}
+
+void KeywordEditorView::AddNodeToList(int model_row) {
+  GtkTreeIter iter;
+  int row = GetListStoreRowForModelRow(model_row);
+  if (row == 0) {
+    gtk_list_store_prepend(list_store_, &iter);
+  } else {
+    GtkTreeIter sibling;
+    gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), &sibling,
+                                  NULL, row - 1);
+    gtk_list_store_insert_after(list_store_, &iter, &sibling);
+  }
+
+  SetColumnValues(model_row, &iter);
+}
+
+void KeywordEditorView::OnModelChanged() {
+  model_second_group_index_ = table_model_->last_search_engine_index();
+  gtk_list_store_clear(list_store_);
+
+  TableModel::Groups groups(table_model_->GetGroups());
+  if (groups.size() != 2) {
+    NOTREACHED();
+    return;
+  }
+
+  GtkTreeIter iter;
+  // First group title.
+  gtk_list_store_append(list_store_, &iter);
+  gtk_list_store_set(
+      list_store_, &iter,
+      COL_WEIGHT, PANGO_WEIGHT_BOLD,
+      COL_WEIGHT_SET, TRUE,
+      COL_TITLE, WideToUTF8(groups[0].title).c_str(),
+      COL_IS_HEADER, TRUE,
+      -1);
+  // First group separator.
+  gtk_list_store_append(list_store_, &iter);
+  gtk_list_store_set(
+      list_store_, &iter,
+      COL_IS_HEADER, TRUE,
+      COL_IS_SEPARATOR, TRUE,
+      -1);
+
+  // Blank row between groups.
+  gtk_list_store_append(list_store_, &iter);
+  gtk_list_store_set(
+      list_store_, &iter,
+      COL_IS_HEADER, TRUE,
+      -1);
+  // Second group title.
+  gtk_list_store_append(list_store_, &iter);
+  gtk_list_store_set(
+      list_store_, &iter,
+      COL_WEIGHT, PANGO_WEIGHT_BOLD,
+      COL_WEIGHT_SET, TRUE,
+      COL_TITLE, WideToUTF8(groups[1].title).c_str(),
+      COL_IS_HEADER, TRUE,
+      -1);
+  // Second group separator.
+  gtk_list_store_append(list_store_, &iter);
+  gtk_list_store_set(
+      list_store_, &iter,
+      COL_IS_HEADER, TRUE,
+      COL_IS_SEPARATOR, TRUE,
+      -1);
+
+  for (int i = 0; i < table_model_->RowCount(); ++i)
+    AddNodeToList(i);
+}
+
+void KeywordEditorView::OnItemsChanged(int start, int length) {
+  DCHECK(model_second_group_index_ == table_model_->last_search_engine_index());
+  GtkTreeIter iter;
+  for (int i = 0; i < length; ++i) {
+    int row = GetListStoreRowForModelRow(start + i);
+    bool rv = gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_),
+        &iter, NULL, row);
+    if (!rv) {
+      NOTREACHED();
+      return;
+    }
+    SetColumnValues(start + i, &iter);
+    rv = gtk_tree_model_iter_next(GTK_TREE_MODEL(list_store_), &iter);
+  }
+}
+
+void KeywordEditorView::OnItemsAdded(int start, int length) {
+  model_second_group_index_ = table_model_->last_search_engine_index();
+  for (int i = 0; i < length; ++i) {
+    AddNodeToList(start + i);
+  }
+}
+
+void KeywordEditorView::OnItemsRemoved(int start, int length) {
+  // This is quite likely not correct with removing multiple in one call, but
+  // that shouldn't happen since we only can select and modify/remove one at a
+  // time.
+  DCHECK(length == 1);
+  for (int i = 0; i < length; ++i) {
+    int row = GetListStoreRowForModelRow(start + i);
+    GtkTreeIter iter;
+    if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(list_store_), &iter,
+                                       NULL, row)) {
+      NOTREACHED();
+      return;
+    }
+    gtk_list_store_remove(list_store_, &iter);
+  }
+  model_second_group_index_ = table_model_->last_search_engine_index();
 }
 
 void KeywordEditorView::OnTemplateURLModelChanged() {
-  // TODO(mattm): repopulate table
   EnableControls();
 }
 
 // static
 void KeywordEditorView::OnWindowDestroy(GtkWidget* widget,
                                         KeywordEditorView* window) {
   instance_ = NULL;
   MessageLoop::current()->DeleteSoon(FROM_HERE, window);
 }
 
 // static
 void KeywordEditorView::OnResponse(GtkDialog* dialog, int response_id,
                                    KeywordEditorView* window) {
   gtk_widget_destroy(window->dialog_);
 }
 
 // static
+gboolean KeywordEditorView::OnCheckRowIsSeparator(GtkTreeModel* model,
+                                                  GtkTreeIter* iter,
+                                                  gpointer user_data) {
+  gboolean is_separator;
+  gtk_tree_model_get(model, iter, COL_IS_SEPARATOR, &is_separator, -1);
+  return is_separator;
+}
+
+//static
+gboolean KeywordEditorView::OnSelectionFilter(GtkTreeSelection *selection,
+                                              GtkTreeModel *model,
+                                              GtkTreePath *path,
+                                              gboolean path_currently_selected,
+                                              gpointer user_data) {
+  GtkTreeIter iter;
+  if (!gtk_tree_model_get_iter(model, &iter, path)) {
+    NOTREACHED();
+    return TRUE;
+  }
+  gboolean is_header;
+  gtk_tree_model_get(model, &iter, COL_IS_HEADER, &is_header, -1);
+  return !is_header;
+}
+
+// static
 void KeywordEditorView::OnSelectionChanged(
     GtkTreeSelection *selection, KeywordEditorView* editor) {
   editor->EnableControls();
 }
 
 // static
+void KeywordEditorView::OnRowActivated(GtkTreeView* tree_view,
+                                       GtkTreePath* path,
+                                       GtkTreeViewColumn* column,
+                                       KeywordEditorView* editor) {
+  OnEditButtonClicked(NULL, editor);
+}
+
+// static
 void KeywordEditorView::OnAddButtonClicked(GtkButton* button,
                                            KeywordEditorView* editor) {
   new EditSearchEngineDialog(
       GTK_WINDOW(gtk_widget_get_toplevel(editor->dialog_)),
       NULL,
       editor,
       editor->profile_);
 }
 
 // static
 void KeywordEditorView::OnEditButtonClicked(GtkButton* button,
                                             KeywordEditorView* editor) {
-  // TODO(mattm)
+  int model_row = editor->GetSelectedModelRow();
+  if (model_row == -1) {
+    NOTREACHED();
+    return;
+  }
+  new EditSearchEngineDialog(
+      GTK_WINDOW(gtk_widget_get_toplevel(editor->dialog_)),
+      editor->controller_->GetTemplateURL(model_row),
+      editor,
+      editor->profile_);
 }
 
 // static
 void KeywordEditorView::OnRemoveButtonClicked(GtkButton* button,
                                               KeywordEditorView* editor) {
-  // TODO(mattm)
+  int model_row = editor->GetSelectedModelRow();
+  if (model_row == -1) {
+    NOTREACHED();
+    return;
+  }
+  editor->controller_->RemoveTemplateURL(model_row);
+  if (model_row >= editor->table_model_->RowCount())
+    model_row = editor->table_model_->RowCount() - 1;
+  if (model_row >= 0)
+    editor->SelectModelRow(model_row);
 }
 
 // static
 void KeywordEditorView::OnMakeDefaultButtonClicked(GtkButton* button,
                                                    KeywordEditorView* editor) {
-  // TODO(mattm)
+  int model_row = editor->GetSelectedModelRow();
+  if (model_row == -1) {
+    NOTREACHED();
+    return;
+  }
+  int new_index = editor->controller_->MakeDefaultTemplateURL(model_row);
+  if (new_index > 0) {
+    editor->SelectModelRow(new_index);
+  }
 }