Experiments with a new tabstrip + animator

chrome/browser/views/frame/browser_view.cc

 // Copyright (c) 2006-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/views/frame/browser_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 21 matching lines @@
 #include "chrome/browser/views/browser_bubble.h"
 #include "chrome/browser/views/browser_dialogs.h"
 #include "chrome/browser/views/chrome_views_delegate.h"
 #include "chrome/browser/views/download_shelf_view.h"
 #include "chrome/browser/views/extensions/extension_shelf.h"
 #include "chrome/browser/views/frame/browser_frame.h"
 #include "chrome/browser/views/fullscreen_exit_bubble.h"
 #include "chrome/browser/views/infobars/infobar_container.h"
 #include "chrome/browser/views/status_bubble_views.h"
 #include "chrome/browser/views/tab_contents/tab_contents_container.h"
+#include "chrome/browser/views/tabs/browser_tab_strip.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
 #include "chrome/browser/views/toolbar_star_toggle.h"
 #include "chrome/browser/views/toolbar_view.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/window_sizer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/native_window_notification_source.h"
@@ skipping 371 matching lines @@
   if (UILayoutIsRightToLeft())
     bounding_box.set_x(bounding_box.x() + scrollbar_width);
 
   return bounding_box;
 }
 
 int BrowserView::GetTabStripHeight() const {
   // We want to return tabstrip_->height(), but we might be called in the midst
   // of layout, when that hasn't yet been updated to reflect the current state.
   // So return what the tabstrip height _ought_ to be right now.
-  return IsTabStripVisible() ? tabstrip_->GetPreferredSize().height() : 0;
+  views::View* tabstrip =
+      TabStrip2::Enabled() ? static_cast<views::View*>(bts_)
+                           : static_cast<views::View*>(tabstrip_);
+  return IsTabStripVisible() ? tabstrip->GetPreferredSize().height() : 0;
 }
 
 gfx::Rect BrowserView::GetTabStripBounds() const {
   return frame_->GetBoundsForTabStrip(tabstrip_);
 }
 
 bool BrowserView::IsToolbarVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
          browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR);
 }
@@ skipping 492 matching lines @@
 }
 
 void BrowserView::ShowHTMLDialog(HtmlDialogUIDelegate* delegate,
                                  gfx::NativeWindow parent_window) {
   // Default to using our window as the parent if the argument is not specified.
   gfx::NativeWindow parent = parent_window ? parent_window
                                            : GetNativeHandle();
   browser::ShowHtmlDialogView(parent, browser_.get(), delegate);
 }
 
+void BrowserView::ContinueDraggingDetachedTab(const gfx::Rect& tab_bounds) {
+  DCHECK(TabStrip2::Enabled());
+  bts_->SetDraggedTabBounds(0, tab_bounds);
+  frame_->ContinueDraggingDetachedTab();
+}
+
 void BrowserView::UserChangedTheme() {
   frame_->GetWindow()->FrameTypeChanged();
   GetRootView()->ThemeChanged();
   GetRootView()->SchedulePaint();
 }
 
 int BrowserView::GetExtraRenderViewHeight() const {
   // Currently this is only used on linux.
   return 0;
 }
@@ skipping 258 matching lines @@
   set_window(window);
   return this;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, views::ClientView overrides:
 
 bool BrowserView::CanClose() const {
   // You cannot close a frame for which there is an active originating drag
   // session.
-  if (tabstrip_->IsDragSessionActive())
+  if (!TabStrip2::Enabled() && tabstrip_->IsDragSessionActive())
     return false;
 
   // Give beforeunload handlers the chance to cancel the close before we hide
   // the window below.
   if (!browser_->ShouldCloseWindow())
     return false;
 
   if (!browser_->tabstrip_model()->empty()) {
     // Tab strip isn't empty.  Hide the frame (so it appears to have closed
     // immediately) and close all the tabs, allowing the renderers to shut
@@ skipping 37 matching lines @@
 #endif
   }
 
   // Determine if the TabStrip exists and is capable of being clicked on. We
   // might be a popup window without a TabStrip.
   if (IsTabStripVisible()) {
     gfx::Point point_in_view_coords(point);
     View::ConvertPointToView(GetParent(), this, &point_in_view_coords);
 
     // See if the mouse pointer is within the bounds of the TabStrip.
-    gfx::Point point_in_tabstrip_coords(point);
-    View::ConvertPointToView(GetParent(), tabstrip_, &point_in_tabstrip_coords);
-    if (tabstrip_->HitTest(point_in_tabstrip_coords)) {
-      if (tabstrip_->PointIsWithinWindowCaption(point_in_tabstrip_coords))
-        return HTCAPTION;
-      return HTCLIENT;
+    if (!TabStrip2::Enabled()) {
+      gfx::Point point_in_tabstrip_coords(point);
+      View::ConvertPointToView(GetParent(), tabstrip_, &point_in_tabstrip_coords);
+      if (tabstrip_->HitTest(point_in_tabstrip_coords)) {
+        if (tabstrip_->PointIsWithinWindowCaption(point_in_tabstrip_coords))
+          return HTCAPTION;
+        return HTCLIENT;
+      }
     }
 
     // The top few pixels of the TabStrip are a drop-shadow - as we're pretty
     // starved of dragable area, let's give it to window dragging (this also
     // makes sense visually).
-    if (!IsMaximized() &&
+    if (!TabStrip2::Enabled() && !IsMaximized() &&
         (point_in_view_coords.y() < tabstrip_->y() + kTabShadowSize)) {
       // We return HTNOWHERE as this is a signal to our containing
       // NonClientView that it should figure out what the correct hit-test
       // code is given the mouse position...
       return HTNOWHERE;
     }
   }
 
   // If the point's y coordinate is below the top of the toolbar and otherwise
   // within the bounds of this view, the point is considered to be within the
   // client area.
   gfx::Rect bv_bounds = bounds();
-  bv_bounds.Offset(0, toolbar_->y());
-  bv_bounds.set_height(bv_bounds.height() - toolbar_->y());
+  if (TabStrip2::Enabled()) {
+    bv_bounds.Offset(0, bts_->y());
+    bv_bounds.set_height(bv_bounds.height() - bts_->y());
+  } else {
+    bv_bounds.Offset(0, toolbar_->y());
+    bv_bounds.set_height(bv_bounds.height() - toolbar_->y());
+  }
   if (bv_bounds.Contains(point))
     return HTCLIENT;
 
   // If the point's y coordinate is above the top of the toolbar, but not in
   // the tabstrip (per previous checking in this function), then we consider it
   // in the window caption (e.g. the area to the right of the tabstrip
   // underneath the window controls). However, note that we DO NOT return
   // HTCAPTION here, because when the window is maximized the window controls
   // will fall into this space (since the BrowserView is sized to entire size
   // of the window at that point), and the HTCAPTION value will cause the
   // window controls not to work. So we return HTNOWHERE so that the caller
   // will hit-test the window controls before finally falling back to
   // HTCAPTION.
   bv_bounds = bounds();
   bv_bounds.set_height(toolbar_->y());
   if (bv_bounds.Contains(point))
     return HTNOWHERE;
 
   // If the point is somewhere else, delegate to the default implementation.
   return views::ClientView::NonClientHitTest(point);
 }
 
 gfx::Size BrowserView::GetMinimumSize() {
+  views::View* tabstrip =
+      TabStrip2::Enabled() ? static_cast<views::View*>(bts_)
+                           : static_cast<views::View*>(tabstrip_);
   // TODO(noname): In theory the tabstrip width should probably be
   // (OTR + tabstrip + caption buttons) width.
   gfx::Size tabstrip_size(
       browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP) ?
-      tabstrip_->GetMinimumSize() : gfx::Size());
+      tabstrip->GetMinimumSize() : gfx::Size());
   gfx::Size toolbar_size(
       (browser_->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
        browser_->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR)) ?
       toolbar_->GetMinimumSize() : gfx::Size());
   if (tabstrip_size.height() && toolbar_size.height())
     toolbar_size.Enlarge(0, -kToolbarTabStripVerticalOverlap);
   gfx::Size bookmark_bar_size;
   if (active_bookmark_bar_ &&
       browser_->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)) {
     bookmark_bar_size = active_bookmark_bar_->GetMinimumSize();
@@ skipping 67 matching lines @@
   // Start a hung plugin window detector for this browser object (as long as
   // hang detection is not disabled).
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableHangMonitor)) {
     InitHangMonitor();
   }
 
   LoadAccelerators();
   SetAccessibleName(l10n_util::GetString(IDS_PRODUCT_NAME));
 
-  tabstrip_ = new TabStrip(browser_->tabstrip_model());
-  tabstrip_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TABSTRIP));
-  AddChildView(tabstrip_);
-  frame_->TabStripCreated(tabstrip_);
+  if (TabStrip2::Enabled()) {
+    bts_ = new BrowserTabStrip(browser_->tabstrip_model());
+    AddChildView(bts_);
+  } else {
+    tabstrip_ = new TabStrip(browser_->tabstrip_model());
+    tabstrip_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TABSTRIP));
+    AddChildView(tabstrip_);
+    frame_->TabStripCreated(tabstrip_);
+  }
 
   toolbar_ = new ToolbarView(browser_.get());
   AddChildView(toolbar_);
   toolbar_->SetID(VIEW_ID_TOOLBAR);
   toolbar_->Init(browser_->profile());
   toolbar_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_TOOLBAR));
 
   infobar_container_ = new InfoBarContainer(this);
   AddChildView(infobar_container_);
 
@@ skipping 28 matching lines @@
   else
     BuildSystemMenuForPopupWindow();
   system_menu_.reset(
       new views::NativeMenuWin(system_menu_contents_.get(),
                                frame_->GetWindow()->GetNativeWindow()));
   system_menu_->Rebuild();
 }
 #endif
 
 int BrowserView::LayoutTabStrip() {
-  gfx::Rect tabstrip_bounds = frame_->GetBoundsForTabStrip(tabstrip_);
-  tabstrip_->SetBackgroundOffset(
-      gfx::Point(tabstrip_bounds.x(), tabstrip_bounds.y()));
+  gfx::Rect tabstrip_bounds;
+  if (TabStrip2::Enabled()) {
+    tabstrip_bounds = gfx::Rect(0, 0, width(),
+                                bts_->GetPreferredSize().height());
+  } else {
+    tabstrip_bounds = frame_->GetBoundsForTabStrip(tabstrip_);
+    tabstrip_->SetBackgroundOffset(
+        gfx::Point(tabstrip_bounds.x(), tabstrip_bounds.y()));
+  }
   gfx::Point tabstrip_origin = tabstrip_bounds.origin();
   ConvertPointToView(GetParent(), this, &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
   bool visible = IsTabStripVisible();
   int y = visible ? tabstrip_bounds.y() : 0;
   int height = visible ? tabstrip_bounds.height() : 0;
-  tabstrip_->SetVisible(visible);
-  tabstrip_->SetBounds(tabstrip_bounds.x(), y, tabstrip_bounds.width(), height);
-  return y + height;
+  int bottom = y + height;
+  if (TabStrip2::Enabled()) {
+    gfx::Size btsps = bts_->GetPreferredSize();
+    bts_->SetBounds(tabstrip_bounds.x(), y, width(), btsps.height());
+  } else {
+    tabstrip_->SetVisible(visible);
+    tabstrip_->SetBounds(tabstrip_bounds.x(), y, tabstrip_bounds.width(), height);
+  }
+  return bottom;
 }
 
 int BrowserView::LayoutToolbar(int top) {
   int browser_view_width = width();
   bool visible = IsToolbarVisible();
   toolbar_->location_bar()->SetFocusable(visible);
   int y = top -
       ((visible && IsTabStripVisible()) ? kToolbarTabStripVerticalOverlap : 0);
   int height = visible ? toolbar_->GetPreferredSize().height() : 0;
   toolbar_->SetVisible(visible);
@@ skipping 290 matching lines @@
 #endif
 }
 
 void BrowserView::LoadingAnimationCallback() {
   if (browser_->type() == Browser::TYPE_NORMAL) {
     // Loading animations are shown in the tab for tabbed windows.  We check the
     // browser type instead of calling IsTabStripVisible() because the latter
     // will return false for fullscreen windows, but we still need to update
     // their animations (so that when they come out of fullscreen mode they'll
     // be correct).
-    tabstrip_->UpdateLoadingAnimations();
+    if (!TabStrip2::Enabled())
+      tabstrip_->UpdateLoadingAnimations();
   } else if (ShouldShowWindowIcon()) {
     // ... or in the window icon area for popups and app windows.
     TabContents* tab_contents = browser_->GetSelectedTabContents();
     // GetSelectedTabContents can return NULL for example under Purify when
     // the animations are running slowly and this function is called on a timer
     // through LoadingAnimationCallback.
     frame_->UpdateThrobber(tab_contents && tab_contents->is_loading());
   }
 }
 
@@ skipping 43 matching lines @@
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }
 
 // static
 void BrowserList::AllBrowsersClosed() {
   views::Window::CloseAllSecondaryWindows();
 }