Implement App Tabs for GTK

chrome/browser/views/tabs/tab_strip.cc

 // Copyright (c) 2010 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/views/tabs/tab_strip.h"
 
 #include "app/animation_container.h"
 #include "app/drag_drop_types.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
@@ skipping 103 matching lines @@
 };
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const int TabStrip::mini_to_non_mini_gap_ = 3;
 
-// static
-const int TabStrip::extra_gap_for_nano_ = 10;
-
 TabStrip::TabStrip(TabStripController* controller)
     : BaseTabStrip(controller, BaseTabStrip::HORIZONTAL_TAB_STRIP),
       resize_layout_factory_(this),
       added_as_message_loop_observer_(false),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
       animation_container_(new AnimationContainer()),
       new_tab_button_enabled_(true) {
@@ skipping 513 matching lines @@
 }
 
 void TabStrip::GetCurrentTabWidths(double* unselected_width,
                                    double* selected_width) const {
   *unselected_width = current_unselected_width_;
   *selected_width = current_selected_width_;
 }
 
 void TabStrip::GetDesiredTabWidths(int tab_count,
                                    int mini_tab_count,
-                                   int nano_tab_count,
                                    double* unselected_width,
                                    double* selected_width) const {
   DCHECK(tab_count >= 0 && mini_tab_count >= 0 && mini_tab_count <= tab_count);
-  DCHECK(nano_tab_count >= 0 && nano_tab_count <= tab_count);
   const double min_unselected_width = Tab::GetMinimumUnselectedSize().width();
   const double min_selected_width = Tab::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;
   }
@@ skipping 18 matching lines @@
 
   if (mini_tab_count > 0) {
     available_width -= mini_tab_count * (Tab::GetMiniWidth() + kTabHOffset);
     tab_count -= mini_tab_count;
     if (tab_count == 0) {
       *selected_width = *unselected_width = Tab::GetStandardSize().width();
       return;
     }
     // Account for gap between the last mini-tab and first non-mini-tab.
     available_width -= mini_to_non_mini_gap_;
-    // And add some extra space if you have nano tabs in the mix.
-    if (nano_tab_count > 0)
-      available_width -= extra_gap_for_nano_;
   }
 
   // Calculate the desired tab widths by dividing the available space into equal
   // portions.  Don't let tabs get larger than the "standard width" or smaller
   // than the minimum width for each type, respectively.
   const int total_offset = kTabHOffset * (tab_count - 1);
   const double desired_tab_width = std::min((static_cast<double>(
       available_width - total_offset) / static_cast<double>(tab_count)),
       static_cast<double>(Tab::GetStandardSize().width()));
   *unselected_width = std::max(desired_tab_width, min_unselected_width);
@@ skipping 40 matching lines @@
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
   int mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == tab_count()) {
     // Only mini-tabs, we know the tab widths won't have changed (all
     // mini-tabs have the same width), so there is nothing to do.
     return;
   }
   Tab* first_tab  = GetTabAtTabDataIndex(mini_tab_count);
   double unselected, selected;
-  GetDesiredTabWidths(tab_count(), mini_tab_count, GetNanoTabCount(),
-                      &unselected, &selected);
+  GetDesiredTabWidths(tab_count(), mini_tab_count, &unselected, &selected);
   int w = Round(first_tab->IsSelected() ? selected : selected);
 
   // We only want to run the animation if we're not already at the desired
   // size.
   if (abs(first_tab->width() - w) > 1)
     StartResizeLayoutAnimation();
 }
 
 bool TabStrip::IsCursorInTabStripZone() const {
   gfx::Rect bounds = GetLocalBounds(true);
@@ skipping 184 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Called from:
 // - BasicLayout
 // - Tab insertion/removal
 // - Tab reorder
 void TabStrip::GenerateIdealBounds() {
   int non_closing_tab_count = 0;
   int mini_tab_count = 0;
-  int nano_tab_count = 0;
   for (int i = 0; i < tab_count(); ++i) {
     BaseTab* tab = base_tab_at_tab_index(i);
     if (!tab->closing()) {
       ++non_closing_tab_count;
       if (tab->data().mini)
         mini_tab_count++;
-      if (tab->data().app)
-        nano_tab_count++;
     }
   }
 
   double unselected, selected;
-  GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, nano_tab_count,
-                      &unselected, &selected);
+  GetDesiredTabWidths(non_closing_tab_count, mini_tab_count, &unselected,
+                      &selected);
 
   current_unselected_width_ = unselected;
   current_selected_width_ = selected;
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   double tab_x = 0;
   bool last_was_mini = false;
   for (int i = 0; i < tab_count(); ++i) {
       Tab* tab = GetTabAtTabDataIndex(i);
     if (!tab->closing()) {
       double tab_width = unselected;
       if (tab->data().mini) {
         tab_width = Tab::GetMiniWidth();
       } else {
         if (last_was_mini) {
           // Give a bigger gap between mini and non-mini tabs.
           tab_x += mini_to_non_mini_gap_;
-          if (nano_tab_count > 0)
-            tab_x += extra_gap_for_nano_;
         }
         if (tab->IsSelected())
           tab_width = selected;
       }
       double end_of_tab = tab_x + tab_width;
       int rounded_tab_x = Round(tab_x);
       set_ideal_bounds(i,
           gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height));
       tab_x = end_of_tab + kTabHOffset;
@@ skipping 93 matching lines @@
   int mini_count = 0;
   for (int i = 0; i < tab_count(); ++i) {
     if (base_tab_at_tab_index(i)->data().mini)
       mini_count++;
     else
       return mini_count;
   }
   return mini_count;
 }
 
-int TabStrip::GetNanoTabCount() const {
-  int nano_count = 0;
-  for (int i = 0; i < tab_count(); ++i) {
-    if (base_tab_at_tab_index(i)->data().app)
-      nano_count++;
-    else
-      return nano_count;
-  }
-  return nano_count;
-}
-
 int TabStrip::GetAvailableWidthForTabs(Tab* last_tab) const {
   return last_tab->x() + last_tab->width();
 }
 
 bool TabStrip::IsPointInTab(Tab* tab,
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }
@@ skipping 16 matching lines @@
   }
 }
 
 bool TabStrip::HasPhantomTabs() const {
   for (int i = 0; i < tab_count(); ++i) {
     if (GetTabAtTabDataIndex(i)->data().phantom)
       return true;
   }
   return false;
 }