Implement a GTK LocationBarView and Autocomplete.

chrome/browser/gtk/browser_toolbar_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/browser_toolbar_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "base/logging.h"
 #include "base/base_paths_linux.h"
 #include "base/path_service.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
+#include "chrome/browser/gtk/back_forward_menu_model_gtk.h"
 #include "chrome/browser/gtk/custom_button.h"
-#include "chrome/browser/gtk/back_forward_menu_model_gtk.h"
+#include "chrome/browser/gtk/location_bar_view_gtk.h"
 #include "chrome/browser/gtk/standard_menus.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/resource_bundle.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
-// TODO(deanm): Remove this when the LocationBarView is used.
-class LocationBar;
-
 const int BrowserToolbarGtk::kToolbarHeight = 38;
 // For the back/forward dropdown menus, the time in milliseconds between
 // when the user clicks and the popup menu appears.
 static const int kMenuTimerDelay = 500;
 
+static void OnGrabFocusThunk(GtkWidget* toolbar, gpointer self) {
+  reinterpret_cast<BrowserToolbarGtk*>(self)->FocusLocationBar();
+}
+
 BrowserToolbarGtk::BrowserToolbarGtk(Browser* browser)
     : toolbar_(NULL),
-      entry_(NULL),
+      location_bar_(new LocationBarViewGtk(browser->command_updater(),
+                                           browser->toolbar_model())),
       model_(browser->toolbar_model()),
       browser_(browser),
       profile_(NULL),
       show_menu_factory_(this) {
   browser_->command_updater()->AddCommandObserver(IDC_BACK, this);
   browser_->command_updater()->AddCommandObserver(IDC_FORWARD, this);
   browser_->command_updater()->AddCommandObserver(IDC_RELOAD, this);
   browser_->command_updater()->AddCommandObserver(IDC_HOME, this);
   browser_->command_updater()->AddCommandObserver(IDC_STAR, this);
 
   back_menu_model_.reset(new BackForwardMenuModelGtk(
       browser, BackForwardMenuModel::BACKWARD_MENU_DELEGATE));
   forward_menu_model_.reset(new BackForwardMenuModelGtk(
       browser, BackForwardMenuModel::FORWARD_MENU_DELEGATE));
 }
 
 BrowserToolbarGtk::~BrowserToolbarGtk() {
 }
 
 void BrowserToolbarGtk::Init(Profile* profile, GtkAccelGroup* accel_group) {
+  // Make sure to tell the location bar the profile before calling its Init.
+  SetProfile(profile);
+
   accel_group_ = accel_group;
 
   show_home_button_.Init(prefs::kShowHomeButton, profile->GetPrefs(), this);
 
   toolbar_ = gtk_hbox_new(FALSE, 0);
   gtk_container_set_border_width(GTK_CONTAINER(toolbar_), 4);
   // Demand we're always at least kToolbarHeight tall.
   // -1 for width means "let GTK do its normal sizing".
   gtk_widget_set_size_request(toolbar_, -1, kToolbarHeight);
 
@@ skipping 17 matching lines @@
   // TODO(port): we need to dynamically react to changes in show_home_button_
   // and hide/show home appropriately.  But we don't have a UI for it yet.
   if (*show_home_button_)
     home_.reset(MakeHomeButton());
 
   gtk_box_pack_start(GTK_BOX(toolbar_), gtk_label_new("  "), FALSE, FALSE, 0);
 
   star_.reset(BuildToolbarButton(IDR_STAR, IDR_STAR_P, IDR_STAR_H, IDR_STAR_D,
       l10n_util::GetString(IDS_TOOLTIP_STAR)));
 
-  entry_ = gtk_entry_new();
-  gtk_widget_set_size_request(entry_, 0, 27);
-  g_signal_connect(G_OBJECT(entry_), "activate",
-                   G_CALLBACK(OnEntryActivate), this);
-  g_signal_connect(G_OBJECT(entry_), "focus",
-                   G_CALLBACK(OnEntryFocus), this);
-  g_signal_connect(G_OBJECT(entry_), "focus-in-event",
-                   G_CALLBACK(OnEntryFocusIn), this);
-  g_signal_connect(G_OBJECT(entry_), "focus-out-event",
-                   G_CALLBACK(OnEntryFocusOut), this);
+  location_bar_->Init();
+  gtk_box_pack_start(GTK_BOX(toolbar_), location_bar_->widget(), TRUE, TRUE, 0);
+
+  // We listen for ctrl-l which we have send a grab-focus action to the
+  // toolbar.  We want our callback to just call FocusLocationBar().
+  g_signal_connect(toolbar_, "grab-focus",
+                   G_CALLBACK(OnGrabFocusThunk), this);
   gtk_widget_add_accelerator(
-      entry_, "grab-focus", accel_group_, GDK_l,
+      toolbar_, "grab-focus", accel_group_, GDK_l,
       GDK_CONTROL_MASK, GtkAccelFlags(0));
 
-  gtk_box_pack_start(GTK_BOX(toolbar_), entry_, TRUE, TRUE, 0);
-
   go_.reset(BuildToolbarButton(IDR_GO, IDR_GO_P, IDR_GO_H, 0, L""));
 
   gtk_box_pack_start(GTK_BOX(toolbar_), gtk_label_new(" "), FALSE, FALSE, 0);
 
   page_menu_button_.reset(BuildToolbarMenuButton(IDR_MENU_PAGE,
       l10n_util::GetString(IDS_PAGEMENU_TOOLTIP)));
   page_menu_.reset(new MenuGtk(this, GetStandardPageMenu(), accel_group_));
 
   app_menu_button_.reset(BuildToolbarMenuButton(IDR_MENU_CHROME,
       l10n_util::GetStringF(IDS_APPMENU_TOOLTIP,
                             l10n_util::GetString(IDS_PRODUCT_NAME))));
   app_menu_.reset(new MenuGtk(this, GetStandardAppMenu(), accel_group_));
-
-  SetProfile(profile);
 }
 
 void BrowserToolbarGtk::AddToolbarToBox(GtkWidget* box) {
   gtk_box_pack_start(GTK_BOX(box), toolbar_, FALSE, FALSE, 0);
 }
 
 LocationBar* BrowserToolbarGtk::GetLocationBar() const {
-  NOTIMPLEMENTED();
-  return NULL;
+  return location_bar_.get();
 }
 
 void BrowserToolbarGtk::FocusLocationBar() {
-  gtk_widget_grab_focus(entry_);
+  location_bar_->FocusLocation();
 }
 
 void BrowserToolbarGtk::EnabledStateChangedForCommand(int id, bool enabled) {
   GtkWidget* widget = NULL;
   switch (id) {
     case IDC_BACK:
       widget = back_->widget();
       break;
     case IDC_FORWARD:
       widget = forward_->widget();
@@ skipping 43 matching lines @@
       NOTIMPLEMENTED();
     }
   }
 }
 
 void BrowserToolbarGtk::SetProfile(Profile* profile) {
   if (profile == profile_)
     return;
 
   profile_ = profile;
-  // TODO(erg): location_bar_ is a normal gtk text box right now. Change this
-  // when we get omnibox support.
-  //  location_bar_->SetProfile(profile);
+  location_bar_->SetProfile(profile);
 }
 
 void BrowserToolbarGtk::UpdateTabContents(TabContents* contents,
                                           bool should_restore_state) {
-  // Extract the UTF-8 representation of the URL.
-  gtk_entry_set_text(GTK_ENTRY(entry_),
-                     contents->GetURL().possibly_invalid_spec().c_str());
+  location_bar_->Update(should_restore_state ? contents : NULL);
 }
 
 CustomDrawButton* BrowserToolbarGtk::BuildToolbarButton(
     int normal_id, int active_id, int highlight_id, int depressed_id,
     const std::wstring& localized_tooltip) {
   CustomDrawButton* button = new CustomDrawButton(normal_id, active_id,
       highlight_id, depressed_id);
 
   gtk_tooltips_set_tip(GTK_TOOLTIPS(toolbar_tooltips_),
                        GTK_WIDGET(button->widget()),
@@ skipping 24 matching lines @@
   g_signal_connect(G_OBJECT(button->widget()), "button-press-event",
                    G_CALLBACK(OnMenuButtonPressEvent), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
 
   gtk_box_pack_start(GTK_BOX(toolbar_), button->widget(), FALSE, FALSE, 0);
 
   return button;
 }
 
 // static
-void BrowserToolbarGtk::OnEntryActivate(GtkEntry *entry,
-                                        BrowserToolbarGtk* toolbar) {
-  GURL dest(URLFixerUpper::FixupURL(std::string(gtk_entry_get_text(entry)),
-                                    std::string()));
-  toolbar->browser_->GetSelectedTabContents()->
-      OpenURL(dest, GURL(), CURRENT_TAB, PageTransition::TYPED);
-}
-
-// static
-gboolean BrowserToolbarGtk::OnEntryFocus(GtkWidget* widget,
-                                         GtkDirectionType direction,
-                                         BrowserToolbarGtk* host) {
-  if (!GTK_WIDGET_HAS_FOCUS(widget)) {
-    gtk_widget_grab_focus(widget);
-    return TRUE;
-  }
-
-  return FALSE;
-}
-
-// static
-gboolean BrowserToolbarGtk::OnEntryFocusIn(GtkWidget* widget,
-                                           GdkEventFocus* focus,
-                                           BrowserToolbarGtk* host) {
-  // Set the caret at the end of the text.
-  gtk_editable_set_position(GTK_EDITABLE(widget), -1);
-  return FALSE;
-}
-
-// static
-gboolean BrowserToolbarGtk::OnEntryFocusOut(GtkWidget* widget,
-                                            GdkEventFocus* focus,
-                                            BrowserToolbarGtk* host) {
-  // Clear the selected text (if any).
-  gtk_editable_set_position(GTK_EDITABLE(widget), 0);
-  return FALSE;
-}
-
-// static
 void BrowserToolbarGtk::OnButtonClick(GtkWidget* button,
                                       BrowserToolbarGtk* toolbar) {
   int tag = -1;
   if (button == toolbar->back_->widget())
     tag = IDC_BACK;
   else if (button == toolbar->forward_->widget())
     tag = IDC_FORWARD;
   else if (button == toolbar->reload_->widget())
     tag = IDC_RELOAD;
   else if (button == toolbar->go_->widget())
@@ skipping 101 matching lines @@
 }
 
 void BrowserToolbarGtk::RunAppMenu(GdkEvent* button_press_event) {
   app_menu_->Popup(app_menu_button_->widget(), button_press_event);
 }
 
 CustomDrawButton* BrowserToolbarGtk::MakeHomeButton() {
   return BuildToolbarButton(IDR_HOME, IDR_HOME_P, IDR_HOME_H, 0,
                             l10n_util::GetString(IDS_TOOLTIP_HOME));
 }