Add a first attempt at a compact location bar and a status bar. The status ba...

chrome/browser/gtk/tabs/tab_strip_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/tabs/tab_strip_gtk.h"
 
 #include <algorithm>
 
 #include "app/gfx/canvas_paint.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/gfx/gtk_util.h"
 #include "base/gfx/point.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/gtk/custom_button.h"
 #include "chrome/browser/gtk/gtk_dnd_util.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/tabs/dragged_tab_controller_gtk.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/notification_type.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 
-#if defined(OS_CHROMEOS)
-#include "chrome/browser/browser.h"
-#include "chrome/browser/browser_list.h"
-#include "chrome/browser/gtk/browser_window_gtk.h"
-#include "chrome/browser/metrics/user_metrics.h"
-#include "chrome/browser/views/tabs/tab_overview_types.h"
-#include "chrome/common/x11_util.h"
-#endif
-
 namespace {
 
 const int kDefaultAnimationDurationMs = 100;
 const int kResizeLayoutAnimationDurationMs = 166;
 const int kReorderAnimationDurationMs = 166;
 const int kAnimateToBoundsDurationMs = 150;
 const int kPinnedTabAnimationDurationMs = 166;
 
 const int kNewTabButtonHOffset = -5;
 const int kNewTabButtonVOffset = 5;
@@ skipping 665 matching lines @@
                    G_CALLBACK(OnDragMotion), this);
   g_signal_connect(G_OBJECT(tabstrip_.get()), "drag-drop",
                    G_CALLBACK(OnDragDrop), this);
   g_signal_connect(G_OBJECT(tabstrip_.get()), "drag-leave",
                    G_CALLBACK(OnDragLeave), this);
   g_signal_connect(G_OBJECT(tabstrip_.get()), "drag-data-received",
                    G_CALLBACK(OnDragDataReceived), this);
 
   newtab_button_.reset(MakeNewTabButton());
 
-#if defined(OS_CHROMEOS)
-  tab_overview_button_.reset(MakeTabOverviewButton());
-#endif
-
   gtk_widget_show_all(tabstrip_.get());
 
   bounds_ = GetInitialWidgetBounds(tabstrip_.get());
 
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     GdkPixbuf* drop_image = GetDropArrowImage(true);
     drop_indicator_width = gdk_pixbuf_get_width(drop_image);
     drop_indicator_height = gdk_pixbuf_get_height(drop_image);
   }
@@ skipping 19 matching lines @@
   int tab_right = 0;
   for (int i = 0; i < tab_count; ++i) {
     const gfx::Rect& bounds = tab_data_.at(i).ideal_bounds;
     TabGtk* tab = GetTabAt(i);
     SetTabBounds(tab, bounds);
     tab_right = bounds.right();
     tab_right += GetTabHOffset(i + 1);
   }
 
   LayoutNewTabButton(static_cast<double>(tab_right), current_unselected_width_);
-#if defined(OS_CHROMEOS)
-  LayoutTabOverviewButton();
-#endif
   gtk_widget_queue_draw(tabstrip_.get());
 }
 
 void TabStripGtk::SchedulePaint() {
   gtk_widget_queue_draw(tabstrip_.get());
 }
 
 void TabStripGtk::SetBounds(const gfx::Rect& bounds) {
   bounds_ = bounds;
 }
@@ skipping 456 matching lines @@
 
 void TabStripGtk::LayoutNewTabButton(double last_tab_right,
                                      double unselected_width) {
   gfx::Rect bounds(0, kNewTabButtonVOffset,
                    newtab_button_->width(), newtab_button_->height());
   int delta = abs(Round(unselected_width) - TabGtk::GetStandardSize().width());
   if (delta > 1 && !resize_layout_scheduled_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
-#if defined(OS_CHROMEOS)
-    bounds.set_x(bounds_.width() - newtab_button_->width() -
-                 tab_overview_button_->width());
-#else
     bounds.set_x(bounds_.width() - newtab_button_->width());
-#endif
   } else {
     bounds.set_x(Round(last_tab_right - kTabHOffset) + kNewTabButtonHOffset);
   }
   bounds.set_x(gtk_util::MirroredLeftPointForRect(tabstrip_.get(), bounds));
 
   gtk_fixed_move(GTK_FIXED(tabstrip_.get()), newtab_button_->widget(),
                  bounds.x(), bounds.y());
 }
 
-#if defined OS_CHROMEOS
-void TabStripGtk::LayoutTabOverviewButton() {
-  gtk_fixed_move(GTK_FIXED(tabstrip_.get()), tab_overview_button_->widget(),
-                 bounds_.width() - tab_overview_button_->width(), 0);
-}
-#endif
-
 void TabStripGtk::GetDesiredTabWidths(int tab_count,
                                       int pinned_tab_count,
                                       double* unselected_width,
                                       double* selected_width) const {
   DCHECK(tab_count >= 0 && pinned_tab_count >= 0 &&
          pinned_tab_count <= tab_count);
   const double min_unselected_width =
       TabGtk::GetMinimumUnselectedSize().width();
   const double min_selected_width =
       TabGtk::GetMinimumSelectedSize().width();
 
   *unselected_width = min_unselected_width;
   *selected_width = min_selected_width;
 
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     return;
   }
 
   // Determine how much space we can actually allocate to tabs.
   int available_width = tabstrip_->allocation.width;
   if (available_width_for_tabs_ < 0) {
     available_width = bounds_.width();
     available_width -=
         (kNewTabButtonHOffset + newtab_button_->width());
-#if defined(OS_CHROMEOS)
-    available_width -= tab_overview_button_->width();
-#endif
   } else {
     // Interesting corner case: if |available_width_for_tabs_| > the result
     // of the calculation in the conditional arm above, the strip is in
     // overflow.  We can either use the specified width or the true available
     // width here; the first preserves the consistent "leave the last tab under
     // the user's mouse so they can close many tabs" behavior at the cost of
     // prolonging the glitchy appearance of the overflow state, while the second
     // gets us out of overflow as soon as possible but forces the user to move
     // their mouse for a few tabs' worth of closing.  We choose visual
     // imperfection over behavioral imperfection and select the first option.
@@ skipping 366 matching lines @@
     double tab_width = TabAnimation::GetCurrentTabWidth(this, animation, i);
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     TabGtk* tab = GetTabAt(i);
     gfx::Rect bounds(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                      tab_height);
     SetTabBounds(tab, bounds);
     tab_x = end_of_tab + GetTabHOffset(i + 1);
   }
   LayoutNewTabButton(tab_x, unselected_width);
-#if defined(OS_CHROMEOS)
-  LayoutTabOverviewButton();
-#endif
   gtk_widget_queue_draw(tabstrip_.get());
 }
 
 void TabStripGtk::StartInsertTabAnimation(int index) {
   // The TabStrip can now use its entire width to lay out Tabs.
   available_width_for_tabs_ = -1;
   if (active_animation_.get())
     active_animation_->Stop();
   active_animation_.reset(new InsertTabAnimation(this, index));
   active_animation_->Start();
@@ skipping 78 matching lines @@
   event->area.x = 0;
   event->area.y = 0;
   event->area.width = tabstrip->bounds_.width();
   event->area.height = tabstrip->bounds_.height();
   gdk_region_union_with_rect(event->region, &event->area);
 
   // Paint the New Tab button.
   gtk_container_propagate_expose(GTK_CONTAINER(tabstrip->tabstrip_.get()),
       tabstrip->newtab_button_->widget(), event);
 
-#if defined(OS_CHROMEOS)
-  // Paint the tab overview button.
-  gtk_container_propagate_expose(GTK_CONTAINER(tabstrip->tabstrip_.get()),
-      tabstrip->tab_overview_button_->widget(), event);
-#endif
-
   // Paint the tabs in reverse order, so they stack to the left.
   TabGtk* selected_tab = NULL;
   int tab_count = tabstrip->GetTabCount();
   for (int i = tab_count - 1; i >= 0; --i) {
     TabGtk* tab = tabstrip->GetTabAt(i);
     // We must ask the _Tab's_ model, not ourselves, because in some situations
     // the model will be different to this object, e.g. when a Tab is being
     // removed after its TabContents has been destroyed.
     if (!tab->IsSelected()) {
       gtk_container_propagate_expose(GTK_CONTAINER(tabstrip->tabstrip_.get()),
@@ skipping 107 matching lines @@
   CustomDrawButton* button = new CustomDrawButton(IDR_NEWTAB_BUTTON,
       IDR_NEWTAB_BUTTON_P, IDR_NEWTAB_BUTTON_H, 0);
 
   g_signal_connect(G_OBJECT(button->widget()), "clicked",
                    G_CALLBACK(OnNewTabClicked), this);
   GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
   gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
 
   return button;
 }
-
-#if defined(OS_CHROMEOS)
-CustomDrawButton* TabStripGtk::MakeTabOverviewButton() {
-  CustomDrawButton* button =
-      new CustomDrawButton(IDR_TAB_OVERVIEW_BUTTON_ICON, 0, 0, 0);
-
-  g_signal_connect(G_OBJECT(button->widget()), "clicked",
-                   G_CALLBACK(OnTabOverviewButtonClicked), this);
-  GTK_WIDGET_UNSET_FLAGS(button->widget(), GTK_CAN_FOCUS);
-  gtk_fixed_put(GTK_FIXED(tabstrip_.get()), button->widget(), 0, 0);
-
-  return button;
-}
-
-// static
-void TabStripGtk::OnTabOverviewButtonClicked(GtkWidget* widget,
-                                             TabStripGtk* tabstrip) {
-  Browser* browser = BrowserList::GetLastActive();
-  DCHECK(browser);  // In order for the user to click on the tab there should
-                    // be an active browser.
-  TabOverviewTypes::Message message;
-  message.set_type(TabOverviewTypes::Message::WM_SWITCH_TO_OVERVIEW_MODE);
-  GtkWidget* browser_widget = GTK_WIDGET(
-      static_cast<BrowserWindowGtk*>(browser->window())->GetNativeHandle());
-  message.set_param(0, x11_util::GetX11WindowFromGtkWidget(browser_widget));
-  TabOverviewTypes::instance()->SendMessage(message);
-
-  UserMetrics::RecordAction(L"TabOverview_PressedTabOverviewButton",
-                            tabstrip->model_->profile());
-}
-#endif