Implement location only display mode (used by popup windows).

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 <X11/XF86keysym.h>
 
 #include "app/l10n_util.h"
@@ skipping 29 matching lines @@
 #include "chrome/common/url_constants.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 
 namespace {
 
 // Height of the toolbar in pixels.
 const int kToolbarHeight = 37;
 
+// Height of the toolbar in pixels when we only show the location bar.
+const int kToolbarHeightLocationBarOnly = kToolbarHeight - 10;
+
 // Interior spacing between toolbar widgets.
 const int kToolbarWidgetSpacing = 4;
 
 // The amount of space between the bottom of the star and the top of the
 // Omnibox results popup window.  We want a two pixel space between the bottom
 // and the results, but have some extra space below the buttons already.
 const int kPopupTopMargin = 0;
 
 // Space between the edge of the star/go button and the popup frame.  We want
 // to leave 1 pixel on both side here so that the borders line up.
@@ skipping 67 matching lines @@
   SetProfile(profile);
 
   theme_provider_ = GtkThemeProvider::GetFrom(profile);
 
   show_home_button_.Init(prefs::kShowHomeButton, profile->GetPrefs(), this);
 
   event_box_ = gtk_event_box_new();
 
   toolbar_ = gtk_hbox_new(FALSE, kToolbarWidgetSpacing);
   gtk_container_add(GTK_CONTAINER(event_box_), toolbar_);
-  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);
+  gtk_container_set_border_width(GTK_CONTAINER(toolbar_),
+      ShouldOnlyShowLocation() ? 0 : 4);
+  // Force the height of the toolbar so we get the right amount of padding
+  // above and below the location bar. -1 for width means "let GTK do its
+  // normal sizing".
+  gtk_widget_set_size_request(toolbar_, -1, ShouldOnlyShowLocation() ?
+      kToolbarHeightLocationBarOnly : kToolbarHeight);
   g_signal_connect(toolbar_, "expose-event",
                    G_CALLBACK(&OnToolbarExpose), this);
 
   // A GtkAccelGroup is not InitiallyUnowned, meaning we get a real reference
   // count starting at one.  We don't want the lifetime to be managed by the
   // top level window, since the lifetime should be tied to the C++ object.
   // When we add the accelerator group, the window will take a reference, but
   // we still hold on to the original, and thus own a reference to the group.
   accel_group_ = gtk_accel_group_new();
   gtk_window_add_accel_group(top_level_window, accel_group_);
@@ skipping 18 matching lines @@
                                  l10n_util::GetStringUTF8(IDS_TOOLTIP_HOME),
                                  GTK_STOCK_HOME));
   gtk_util::SetButtonTriggersNavigation(home_->widget());
   SetUpDragForHomeButton();
 
   // Group the start, omnibox, and go button into an hbox.
   GtkWidget* location_hbox = gtk_hbox_new(FALSE, 0);
   star_.reset(BuildStarButton(l10n_util::GetStringUTF8(IDS_TOOLTIP_STAR)));
   gtk_box_pack_start(GTK_BOX(location_hbox), star_->widget(), FALSE, FALSE, 0);
 
-  location_bar_->Init();
+  location_bar_->Init(ShouldOnlyShowLocation());
   gtk_box_pack_start(GTK_BOX(location_hbox), location_bar_->widget(), TRUE,
                      TRUE, 0);
 
   go_.reset(new GoButtonGtk(location_bar_.get(), browser_));
   gtk_box_pack_start(GTK_BOX(location_hbox), go_->widget(), FALSE, FALSE, 0);
 
   g_signal_connect(location_hbox, "expose-event",
                    G_CALLBACK(OnLocationHboxExpose), this);
-  gtk_box_pack_start(GTK_BOX(toolbar_), location_hbox, TRUE, TRUE, 0);
+  gtk_box_pack_start(GTK_BOX(toolbar_), location_hbox, TRUE, TRUE,
+                     ShouldOnlyShowLocation() ? 1 : 0);
 
   // Group the menu buttons together in an hbox.
   GtkWidget* menus_hbox_ = gtk_hbox_new(FALSE, 0);
   GtkWidget* page_menu = BuildToolbarMenuButton(
       l10n_util::GetStringUTF8(IDS_PAGEMENU_TOOLTIP),
       &page_menu_button_);
   page_menu_image_ = gtk_image_new_from_pixbuf(
       theme_provider_->GetRTLEnabledPixbufNamed(IDR_MENU_PAGE));
   gtk_container_add(GTK_CONTAINER(page_menu), page_menu_image_);
 
@@ skipping 15 matching lines @@
   gtk_container_add(GTK_CONTAINER(chrome_menu), app_menu_image_);
   app_menu_.reset(new MenuGtk(this, GetStandardAppMenu(), accel_group_));
   g_signal_connect(app_menu_->widget(), "motion-notify-event",
                    G_CALLBACK(OnPageAppMenuMouseMotion), this);
   g_signal_connect(app_menu_->widget(), "move-current",
                    G_CALLBACK(OnPageAppMenuMoveCurrent), this);
   gtk_box_pack_start(GTK_BOX(menus_hbox_), chrome_menu, FALSE, FALSE, 0);
 
   gtk_box_pack_start(GTK_BOX(toolbar_), menus_hbox_, FALSE, FALSE, 0);
 
-  gtk_widget_show_all(event_box_);
+  if (ShouldOnlyShowLocation()) {
+    gtk_widget_show(event_box_);
+    gtk_widget_show(toolbar_);
+    gtk_widget_show_all(location_hbox);
+    gtk_widget_hide(star_->widget());
+    gtk_widget_hide(go_->widget());
+  } else {
+    gtk_widget_show_all(event_box_);
 
-  if (show_home_button_.GetValue()) {
-    gtk_widget_show(home_->widget());
-  } else {
-    gtk_widget_hide(home_->widget());
+    if (show_home_button_.GetValue()) {
+      gtk_widget_show(home_->widget());
+    } else {
+      gtk_widget_hide(home_->widget());
+    }
   }
 }
 
 void BrowserToolbarGtk::AddToolbarToBox(GtkWidget* box) {
   gtk_box_pack_start(GTK_BOX(box), event_box_, FALSE, FALSE, 0);
 }
 
 void BrowserToolbarGtk::Show() {
   gtk_widget_show(toolbar_);
 }
@@ skipping 71 matching lines @@
 }
 
 // NotificationObserver --------------------------------------------------------
 
 void BrowserToolbarGtk::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   if (type == NotificationType::PREF_CHANGED) {
     std::wstring* pref_name = Details<std::wstring>(details).ptr();
     if (*pref_name == prefs::kShowHomeButton) {
-      if (show_home_button_.GetValue()) {
+      if (show_home_button_.GetValue() && !ShouldOnlyShowLocation()) {
         gtk_widget_show(home_->widget());
       } else {
         gtk_widget_hide(home_->widget());
       }
     }
   } else if (type == NotificationType::BROWSER_THEME_CHANGED) {
     // Update the spacing around the menu buttons
     int border = theme_provider_->UseGtkTheme() ? 0 : 2;
     gtk_container_set_border_width(
         GTK_CONTAINER(page_menu_button_.get()), border);
@@ skipping 150 matching lines @@
       e->area.x + e->area.width - tabstrip_origin.x());
   cairo_destroy(cr);
 
   return FALSE;  // Allow subwidgets to paint.
 }
 
 // static
 gboolean BrowserToolbarGtk::OnLocationHboxExpose(GtkWidget* location_hbox,
                                                  GdkEventExpose* e,
                                                  BrowserToolbarGtk* toolbar) {
-  if (toolbar->theme_provider_->UseGtkTheme()) {
+  if (toolbar->theme_provider_->UseGtkTheme() &&
+      !toolbar->ShouldOnlyShowLocation()) {
     // To get the proper look surrounding the location bar, we fake out the
     // theme engine into drawing a button. We fake out GTK by constructing a
     // box that's from the top left corner of the bookmark button to the bottom
     // right of the go button and fill it with a button's box (or the opposite
     // if in RTL mode).
     GtkWidget* star = toolbar->star_->widget();
     GtkWidget* left = NULL;
     GtkWidget* right = NULL;
     if (gtk_widget_get_direction(star) ==
         GTK_TEXT_DIR_LTR) {
@@ skipping 110 matching lines @@
       // Fall through.
     case GTK_MENU_DIR_PARENT:
       toolbar->ChangeActiveMenu(menu, gtk_get_current_event_time());
       // This signal doesn't have a return value; we have to manually stop its
       // propagation.
       g_signal_stop_emission_by_name(menu, "move-current");
     default:
       break;
   }
 }
+
+bool BrowserToolbarGtk::ShouldOnlyShowLocation() const {
+  // If we're a popup window, only show the location bar (omnibox).
+  return browser_->type() != Browser::TYPE_NORMAL;
+}