Sidebar mini tabs UI (views version)....

chrome/browser/ui/views/frame/browser_view.cc

 // Copyright (c) 2011 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/ui/views/frame/browser_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 33 matching lines @@
 #include "chrome/browser/ui/toolbar/wrench_menu_model.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/browser_dialogs.h"
 #include "chrome/browser/ui/views/default_search_view.h"
 #include "chrome/browser/ui/views/download_shelf_view.h"
 #include "chrome/browser/ui/views/frame/browser_view_layout.h"
 #include "chrome/browser/ui/views/frame/contents_container.h"
 #include "chrome/browser/ui/views/fullscreen_exit_bubble.h"
 #include "chrome/browser/ui/views/location_bar/location_icon_view.h"
+#include "chrome/browser/ui/views/sidebar/browser_sidebar_tab_strip_controller.h"
+#include "chrome/browser/ui/views/sidebar/sidebar_tab_strip.h"
+#include "chrome/browser/ui/views/sidebar/sidebar_tab_strip_host.h"
 #include "chrome/browser/ui/views/status_bubble_views.h"
 #include "chrome/browser/ui/views/tab_contents/tab_contents_container.h"
 #include "chrome/browser/ui/views/tabs/browser_tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_factory.h"
 #include "chrome/browser/ui/views/theme_install_bubble_view.h"
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/browser/ui/views/update_recommended_message_box.h"
 #include "chrome/browser/ui/views/window.h"
 #include "chrome/browser/ui/window_sizer.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/native_window_notification_source.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "gfx/path.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "grit/webkit_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "views/controls/single_split_view.h"
@@ skipping 351 matching lines @@
       last_focused_view_storage_id_(
           views::ViewStorage::GetInstance()->CreateStorageID()),
       frame_(NULL),
       browser_(browser),
       active_bookmark_bar_(NULL),
       tabstrip_(NULL),
       toolbar_(NULL),
       infobar_container_(NULL),
       sidebar_container_(NULL),
       sidebar_split_(NULL),
+      sidebar_tabstrip_controller_(NULL),
       contents_container_(NULL),
       devtools_container_(NULL),
       preview_container_(NULL),
       contents_(NULL),
       contents_split_(NULL),
       initialized_(false),
       ignore_layout_(true)
 #if defined(OS_WIN)
       , hung_window_detector_(&hung_plugin_action_),
       ticker_(0)
@@ skipping 132 matching lines @@
   // vertically at the top edge of the horizontal tab strip (or where it would
   // be).  We expect our parent's origin to be the window origin.
   gfx::Point window_point(point.Add(GetMirroredPosition()));
   window_point.Offset(0, -frame_->GetHorizontalTabStripVerticalOffset(false));
   return window_point;
 }
 
 int BrowserView::GetSidebarWidth() const {
   if (!sidebar_container_ || !sidebar_container_->IsVisible())
     return 0;
-  return sidebar_split_->divider_offset();
+  int sidebar_width = base::i18n::IsRTL() ?
+      sidebar_split_->divider_offset() :
+      sidebar_split_->width() - sidebar_split_->divider_offset();
+  return sidebar_width;
 }
 
 bool BrowserView::IsTabStripVisible() const {
   return browser_->SupportsWindowFeature(Browser::FEATURE_TABSTRIP);
 }
 
 bool BrowserView::UseVerticalTabs() const {
   return browser_->tabstrip_model()->delegate()->UseVerticalTabs();
 }
 
@@ skipping 819 matching lines @@
                           const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::PREF_CHANGED:
       if (*Details<std::string>(details).ptr() == prefs::kShowBookmarkBar &&
           MaybeShowBookmarkBar(browser_->GetSelectedTabContentsWrapper())) {
         Layout();
       }
       break;
 
     case NotificationType::SIDEBAR_CHANGED:
-      if (Details<SidebarContainer>(details)->tab_contents() ==
-          browser_->GetSelectedTabContents()) {
-        UpdateSidebar();
+      if (Details<SidebarChangedDetails>(details)->source->tab() ==
+          GetSelectedTabContentsWrapper()) {
+        UpdateSidebar(Details<SidebarChangedDetails>(details).ptr());
       }
       break;
 
     default:
       NOTREACHED() << "Got a notification we didn't register for!";
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 374 matching lines @@
 }
 
 bool BrowserView::SplitHandleMoved(views::SingleSplitView* view) {
   for (int i = 0; i < view->GetChildViewCount(); ++i)
     view->GetChildViewAt(i)->InvalidateLayout();
   SchedulePaint();
   Layout();
   return false;
 }
 
+void BrowserView::OnSidebarTabStripBoundsChanged(bool is_animating) {
+  sidebar_tabstrip_host_->UpdateWindowEdges();
+  Layout();
+}
+
 views::LayoutManager* BrowserView::CreateLayoutManager() const {
   return new BrowserViewLayout;
 }
 
 void BrowserView::InitTabStrip(TabStripModel* model) {
   // Throw away the existing tabstrip if we're switching display modes.
   scoped_ptr<BaseTabStrip> old_strip(tabstrip_);
   if (tabstrip_) {
     tabstrip_->GetParent()->RemoveChildView(tabstrip_);
   }
 
   BrowserTabStripController* tabstrip_controller =
       new BrowserTabStripController(browser_.get(), model);
 
   tabstrip_ = CreateTabStrip(tabstrip_controller, UseVerticalTabs());
 
   tabstrip_->SetAccessibleName(l10n_util::GetStringUTF16(IDS_ACCNAME_TABSTRIP));
   AddChildView(tabstrip_);
 
   tabstrip_controller->InitFromModel(tabstrip_);
 }
 
+void BrowserView::InitSidebarTabStrip() {
+  if (sidebar_tabstrip_controller_)
+    return;
+
+  sidebar_tabstrip_controller_ =
+      new BrowserSidebarTabStripController(SidebarManager::GetInstance(), this);
+
+  // Create a new sidebar tab strip and pass controller's ownership to it.
+  SidebarTabStrip* sidebar_tabstrip =
+      new SidebarTabStrip(sidebar_tabstrip_controller_);
+  sidebar_tabstrip->SetAccessibleName(
+      l10n_util::GetStringUTF16(IDS_ACCNAME_SIDEBAR_TABSTRIP));
+
+  sidebar_tabstrip_host_.reset(new SidebarTabStripHost(this));
+  // Pass sidebar_tabstrip ownership to sidebar_tabstrip_host_.
+  sidebar_tabstrip_host_->Init(sidebar_tabstrip);
+
+  sidebar_tabstrip_controller_->set_tab_strip(sidebar_tabstrip);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // BrowserView, private:
 
 void BrowserView::Init() {
   SetLayoutManager(CreateLayoutManager());
   // Stow a pointer to this object onto the window handle so that we can get at
   // it later when all we have is a native view.
   GetWidget()->SetNativeWindowProperty(kBrowserViewKey, this);
 
   // Stow a pointer to the browser's profile onto the window handle so that we
@@ skipping 23 matching lines @@
 
   contents_container_ = new TabContentsContainer;
   contents_ = new ContentsContainer(contents_container_);
 
   SkColor bg_color = GetWidget()->GetThemeProvider()->
       GetColor(BrowserThemeProvider::COLOR_TOOLBAR);
 
   bool sidebar_allowed = SidebarManager::IsSidebarAllowed();
   if (sidebar_allowed) {
     sidebar_container_ = new TabContentsContainer;
-    sidebar_container_->SetID(VIEW_ID_SIDE_BAR_CONTAINER);
+    sidebar_container_->SetID(VIEW_ID_SIDEBAR_CONTAINER);
     sidebar_container_->SetVisible(false);
 
+    views::View* leading_view = contents_;
+    views::View* trailing_view = sidebar_container_;
+    // Sidebar ought to stay on the right side of the browser window, where main
+    // page scrollbar is rendered.
+    if (base::i18n::IsRTL())
+      std::swap(leading_view, trailing_view);
     sidebar_split_ = new views::SingleSplitView(
-        contents_,
-        sidebar_container_,
+        leading_view,
+        trailing_view,
         views::SingleSplitView::HORIZONTAL_SPLIT,
         this);
-    sidebar_split_->SetID(VIEW_ID_SIDE_BAR_SPLIT);
+    sidebar_split_->SetID(VIEW_ID_SIDEBAR_SPLIT);
     sidebar_split_->SetAccessibleName(
-        l10n_util::GetStringUTF16(IDS_ACCNAME_SIDE_BAR));
+        l10n_util::GetStringUTF16(IDS_ACCNAME_SIDEBAR));
     sidebar_split_->set_background(
         views::Background::CreateSolidBackground(bg_color));
+    sidebar_split_->set_resize_leading_on_bounds_change(!base::i18n::IsRTL());
   }
 
   devtools_container_ = new TabContentsContainer;
   devtools_container_->SetID(VIEW_ID_DEV_TOOLS_DOCKED);
   devtools_container_->SetVisible(false);
 
   views::View* contents_view = contents_;
   if (sidebar_allowed)
     contents_view = sidebar_split_;
 
@@ skipping 99 matching lines @@
   return UpdateChildViewAndLayout(new_bookmark_bar_view, &active_bookmark_bar_);
 }
 
 bool BrowserView::MaybeShowInfoBar(TabContentsWrapper* contents) {
   // TODO(beng): Remove this function once the interface between
   //             InfoBarContainer, DownloadShelfView and TabContents and this
   //             view is sorted out.
   return true;
 }
 
-void BrowserView::UpdateSidebar() {
-  UpdateSidebarForContents(GetSelectedTabContentsWrapper());
-  Layout();
+void BrowserView::UpdateSidebar(SidebarChangedDetails* details) {
+  DCHECK(GetSelectedTabContentsWrapper() == details->source->tab());
+  InitSidebarTabStrip();
+  switch (details->update_type) {
+    case SidebarChangedDetails::SIDEBAR_STATE_CHANGED:
+      UpdateSidebarForContents(details->source->tab());
+      break;
+    case SidebarChangedDetails::SIDEBAR_PROPS_CHANGED:
+      sidebar_tabstrip_controller_->UpdateState(details->source);
+      break;
+    case SidebarChangedDetails::SIDEBAR_LOADING_STATE_CHANGED:
+      sidebar_tabstrip_controller_->UpdateLoadingState(details->source);
+      break;
+    default:
+      NOTREACHED();
+  }
 }
 
-void BrowserView::UpdateSidebarForContents(TabContentsWrapper* tab_contents) {
+void BrowserView::UpdateSidebarForContents(TabContentsWrapper* tab) {
   if (!sidebar_container_)
     return;  // Happens when sidebar is not allowed.
   if (!SidebarManager::GetInstance())
     return;  // Happens only in tests.
 
+  TabContents* tab_contents = tab ? tab->tab_contents() : NULL;
+
   TabContents* sidebar_contents = NULL;
   if (tab_contents) {
     SidebarContainer* client_host = SidebarManager::GetInstance()->
-        GetActiveSidebarContainerFor(tab_contents->tab_contents());
+        GetActiveSidebarContainerFor(tab);
     if (client_host)
       sidebar_contents = client_host->sidebar_contents();
   }
 
   bool visible = NULL != sidebar_contents &&
                  browser_->SupportsWindowFeature(Browser::FEATURE_SIDEBAR);
 
   bool should_show = visible && !sidebar_container_->IsVisible();
   bool should_hide = !visible && sidebar_container_->IsVisible();
 
   // Update sidebar content.
   TabContents* old_contents = sidebar_container_->tab_contents();
   sidebar_container_->ChangeTabContents(sidebar_contents);
   SidebarManager::GetInstance()->
       NotifyStateChanges(old_contents, sidebar_contents);
 
+  // Lazy initialize sidebar tabstrip.
+  if (SidebarManager::GetInstance()->IsAnySidebarDefinedFor(tab))
+    InitSidebarTabStrip();
+  if (sidebar_tabstrip_controller_)
+    sidebar_tabstrip_controller_->UpdateTabs(tab);
+
   // Update sidebar UI width.
   if (should_show) {
     // Restore split offset.
     int sidebar_width = g_browser_process->local_state()->GetInteger(
         prefs::kExtensionSidebarWidth);
     if (sidebar_width < 0) {
       // Initial load, set to default value.
       sidebar_width = sidebar_split_->width() / 7;
     }
     // Make sure user can see both panes.
     int min_sidebar_width = sidebar_split_->GetMinimumSize().width();
     sidebar_width = std::min(sidebar_split_->width() - min_sidebar_width,
                              std::max(min_sidebar_width, sidebar_width));
 
-    sidebar_split_->set_divider_offset(
-        sidebar_split_->width() - sidebar_width);
+    int divider_offset = base::i18n::IsRTL() ?
+        sidebar_width : (sidebar_split_->width() - sidebar_width);
+    sidebar_split_->set_divider_offset(divider_offset);
 
     sidebar_container_->SetVisible(true);
     sidebar_split_->InvalidateLayout();
     Layout();
   } else if (should_hide) {
     // Store split offset when hiding sidebar only.
+    int sidebar_width = base::i18n::IsRTL() ?
+        sidebar_split_->divider_offset() :
+        sidebar_split_->width() - sidebar_split_->divider_offset();
+
     g_browser_process->local_state()->SetInteger(
-        prefs::kExtensionSidebarWidth,
-        sidebar_split_->width() - sidebar_split_->divider_offset());
+        prefs::kExtensionSidebarWidth, sidebar_width);
 
     sidebar_container_->SetVisible(false);
     sidebar_split_->InvalidateLayout();
     Layout();
   }
 }
 
 void BrowserView::UpdateDevToolsForContents(TabContentsWrapper* wrapper) {
   TabContents* tab_contents = wrapper ? wrapper->tab_contents() : NULL;
   TabContents* devtools_contents =
@@ skipping 465 matching lines @@
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
 
   return view;
 }
 #endif
 
 // static
 FindBar* BrowserWindow::CreateFindBar(Browser* browser) {
   return browser::CreateFindBar(static_cast<BrowserView*>(browser->window()));
 }