Compact Navigation prototype

chrome/browser/ui/views/frame/browser_view_layout.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_layout.h"
 
 #include "chrome/browser/sidebar/sidebar_manager.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/view_ids.h"
@@ skipping 16 matching lines @@
 #include "views/window/hit_test.h"
 #endif
 
 namespace {
 
 // The visible height of the shadow above the tabs. Clicks in this area are
 // treated as clicks to the frame, rather than clicks to the tab.
 const int kTabShadowSize = 2;
 // The vertical overlap between the TabStrip and the Toolbar.
 const int kToolbarTabStripVerticalOverlap = 3;
+// The vertical size of the space between the content area and the tabstrip that
+// is inserted in compact navigation mode. Note that we need to use a height
+// that includes the overlap to get the visible height we want, in order to
+// match how the toolbar overlaps the tabstrip.
+const int kCompactNavbarSpacerVisibleHeight = 4;
+const int kCompactNavbarSpacerHeight =
+    kCompactNavbarSpacerVisibleHeight + kToolbarTabStripVerticalOverlap;
+// The size of the padding between the compact navigation bar and the tab strip.
+const int kCompactNavbarHorizontalPadding = 2;
+// The number of pixels the bookmark bar should overlap the spacer by if the
+// spacer is visible.
+const int kSpacerBookmarkBarOverlap = 1;
+
+// Combines View::ConvertPointToView and View::HitTest for a given |point|.
+// Converts |point| from |src| to |dst| and hit tests it against |dst|. The
+// converted |point| can then be retrieved and used for additional tests.
+bool ConvertedHitTest(views::View* src, views::View* dst, gfx::Point* point) {
+  DCHECK(src);
+  DCHECK(dst);
+  DCHECK(point);
+  views::View::ConvertPointToView(src, dst, point);
+  return dst->HitTest(*point);
+}
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, public:
 
 BrowserViewLayout::BrowserViewLayout()
     : tabstrip_(NULL),
       toolbar_(NULL),
       contents_split_(NULL),
       contents_container_(NULL),
       infobar_container_(NULL),
       download_shelf_(NULL),
       active_bookmark_bar_(NULL),

[sky, 2011/05/09 14:27:22]

Add initializers for new fields.

[SteveT, 2011/05/09 19:40:04]

Done.

       browser_view_(NULL),
       find_bar_y_(0) {
 }
 
 BrowserViewLayout::~BrowserViewLayout() {
 }
 
 gfx::Size BrowserViewLayout::GetMinimumSize() {
   // TODO(noname): In theory the tabstrip width should probably be
   // (OTR + tabstrip + caption buttons) width.
@@ skipping 70 matching lines @@
   // Since the TabStrip only renders in some parts of the top of the window,
   // the un-obscured area is considered to be part of the non-client caption
   // area of the window. So we need to treat hit-tests in these regions as
   // hit-tests of the titlebar.
 
   views::View* parent = browser_view_->parent();
 
   gfx::Point point_in_browser_view_coords(point);
   views::View::ConvertPointToView(
       parent, browser_view_, &point_in_browser_view_coords);
+  gfx::Point test_point(point);
 
   // Determine if the TabStrip exists and is capable of being clicked on. We
   // might be a popup window without a TabStrip.
   if (browser_view_->IsTabStripVisible()) {
     // See if the mouse pointer is within the bounds of the TabStrip.
-    gfx::Point point_in_tabstrip_coords(point);
-    views::View::ConvertPointToView(parent, tabstrip_,
-                                    &point_in_tabstrip_coords);
-    if (tabstrip_->HitTest(point_in_tabstrip_coords)) {
-      if (tabstrip_->IsPositionInWindowCaption(point_in_tabstrip_coords))
+    if (ConvertedHitTest(parent, tabstrip_, &test_point)) {
+      if (tabstrip_->IsPositionInWindowCaption(test_point))
         return HTCAPTION;
       return HTCLIENT;
     }
 
+    // If the tabstrip is visible and we are in compact navigation mode, test
+    // against the compact navigation and option bars.
+    if (browser_view_->UseCompactNavigationBar()) {
+      test_point = point;
+      if (ConvertedHitTest(parent, compact_navigation_bar_, &test_point))
+        return HTCLIENT;
+      test_point = point;
+      if (ConvertedHitTest(parent, compact_options_bar_, &test_point))
+        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 (!browser_view_->IsMaximized() &&
         (point_in_browser_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;
@@ skipping 32 matching lines @@
 // BrowserViewLayout, views::LayoutManager implementation:
 
 void BrowserViewLayout::Installed(views::View* host) {
   toolbar_ = NULL;
   contents_split_ = NULL;
   contents_container_ = NULL;
   infobar_container_ = NULL;
   download_shelf_ = NULL;
   active_bookmark_bar_ = NULL;
   tabstrip_ = NULL;
+  compact_navigation_bar_ = NULL;
+  compact_options_bar_ = NULL;
+  spacer_ = NULL;
   browser_view_ = static_cast<BrowserView*>(host);
 }
 
 void BrowserViewLayout::Uninstalled(views::View* host) {}
 
 void BrowserViewLayout::ViewAdded(views::View* host, views::View* view) {
   switch (view->GetID()) {
     case VIEW_ID_CONTENTS_SPLIT: {
       contents_split_ = static_cast<views::SingleSplitView*>(view);
       // We're installed as the LayoutManager before BrowserView creates the
@@ skipping 10 matching lines @@
       break;
     case VIEW_ID_BOOKMARK_BAR:
       active_bookmark_bar_ = static_cast<BookmarkBarView*>(view);
       break;
     case VIEW_ID_TOOLBAR:
       toolbar_ = static_cast<ToolbarView*>(view);
       break;
     case VIEW_ID_TAB_STRIP:
       tabstrip_ = static_cast<AbstractTabStripView*>(view);
       break;
+    case VIEW_ID_COMPACT_NAV_BAR_SPACER:
+      spacer_ = view;
+      break;
+    case VIEW_ID_COMPACT_NAV_BAR:
+      compact_navigation_bar_ = view;
+      break;
+    case VIEW_ID_COMPACT_OPT_BAR:
+      compact_options_bar_ = view;
+      break;
   }
 }
 
 void BrowserViewLayout::ViewRemoved(views::View* host, views::View* view) {
   switch (view->GetID()) {
     case VIEW_ID_BOOKMARK_BAR:
       active_bookmark_bar_ = NULL;
       break;
   }
 }
 
 void BrowserViewLayout::Layout(views::View* host) {
   vertical_layout_rect_ = browser_view_->GetLocalBounds();
-  int top = LayoutTabStrip();
+  int top = LayoutTabStripRegion();
   if (browser_view_->IsTabStripVisible() && !browser_view_->UseVerticalTabs()) {
     tabstrip_->SetBackgroundOffset(gfx::Point(
         tabstrip_->GetMirroredX() + browser_view_->GetMirroredX(),
         browser_view_->frame()->GetHorizontalTabStripVerticalOffset(false)));
   }
   top = LayoutToolbar(top);
   top = LayoutBookmarkAndInfoBars(top);
   int bottom = LayoutDownloadShelf(browser_view_->height());
   int active_top_margin = GetTopMarginForActiveContent();
   top -= active_top_margin;
   contents_container_->SetActiveTopMargin(active_top_margin);
   LayoutTabContents(top, bottom);
   // This must be done _after_ we lay out the TabContents since this
   // code calls back into us to find the bounding box the find bar
   // must be laid out within, and that code depends on the
   // TabContentsContainer's bounds being up to date.
   if (browser()->HasFindBarController()) {
     browser()->GetFindBarController()->find_bar()->MoveWindowIfNecessary(
         gfx::Rect(), true);
   }
+  if (browser()->UseCompactNavigationBar()) {
+    DCHECK(browser_view_->compact_location_bar_view_host());
+    browser_view_->compact_location_bar_view_host()->MoveWindowIfNecessary(
+        gfx::Rect(), true);
+  }
 }
 
 // Return the preferred size which is the size required to give each
 // children their respective preferred size.
 gfx::Size BrowserViewLayout::GetPreferredSize(views::View* host) {
   return gfx::Size();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, private:
 
 Browser* BrowserViewLayout::browser() {
   return browser_view_->browser();
 }
 
 const Browser* BrowserViewLayout::browser() const {
   return browser_view_->browser();
 }
 
-int BrowserViewLayout::LayoutTabStrip() {
+int BrowserViewLayout::LayoutTabStripRegion() {
   if (!browser_view_->IsTabStripVisible()) {
+    if (compact_navigation_bar_ && compact_options_bar_) {
+      compact_navigation_bar_->SetVisible(false);
+      compact_options_bar_->SetVisible(false);
+    }
     tabstrip_->SetVisible(false);
     tabstrip_->SetBounds(0, 0, 0, 0);
     return 0;
   }
 
+  // This retrieves the bounds for the tab strip based on whether or not we show
+  // anything to the left of it, like the incognito avatar.
   gfx::Rect tabstrip_bounds(
       browser_view_->frame()->GetBoundsForTabStrip(tabstrip_));
   gfx::Point tabstrip_origin(tabstrip_bounds.origin());
   views::View::ConvertPointToView(browser_view_->parent(), browser_view_,
                                   &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
 
+  // If we are in compact nav mode, we want to reduce the tab strip bounds from
+  // both ends enough to lay out the compact navigation and options bars. We
+  // check the pref itself (in browser) rather than the current state since it
+  // determines if the classes have been instantiated. We use the 
+  if (browser_view_->browser()->UseCompactNavigationBar()) {
+    compact_navigation_bar_->SetVisible(
+        browser_view_->UseCompactNavigationBar());
+    compact_options_bar_->SetVisible(browser_view_->UseCompactNavigationBar());
+
+    if (compact_navigation_bar_->IsVisible()) {
+      gfx::Rect cnav_bar_bounds;
+      gfx::Size cnav_bar_size = compact_navigation_bar_->GetPreferredSize();
+      cnav_bar_bounds.set_origin(tabstrip_bounds.origin());
+      cnav_bar_bounds.set_size(cnav_bar_size);
+      compact_navigation_bar_->SetBoundsRect(cnav_bar_bounds);
+
+      // The options bar is flush right of the tab strip region.
+      gfx::Rect copt_bar_bounds;
+      gfx::Size copt_bar_size = compact_options_bar_->GetPreferredSize();
+      copt_bar_bounds.set_x(std::max(0, tabstrip_bounds.right() -
+                            copt_bar_size.width()));
+      copt_bar_bounds.set_y(tabstrip_origin.y());
+      copt_bar_bounds.set_size(copt_bar_size);
+      compact_options_bar_->SetBoundsRect(copt_bar_bounds);
+
+      // Reduce the bounds of the tab strip accordingly.
+      tabstrip_bounds.set_x(tabstrip_bounds.x() + cnav_bar_size.width() +
+          kCompactNavbarHorizontalPadding);
+      tabstrip_bounds.set_width(std::max(0, tabstrip_bounds.width() -
+          cnav_bar_size.width() - copt_bar_size.width() -
+          kCompactNavbarHorizontalPadding * 2));
+    }
+  }
+
   if (browser_view_->UseVerticalTabs())
     vertical_layout_rect_.Inset(tabstrip_bounds.width(), 0, 0, 0);
 
   tabstrip_->SetVisible(true);
   tabstrip_->SetBoundsRect(tabstrip_bounds);
   return browser_view_->UseVerticalTabs() ?
       tabstrip_bounds.y() : tabstrip_bounds.bottom();
 }
 
 int BrowserViewLayout::LayoutToolbar(int top) {
   int browser_view_width = vertical_layout_rect_.width();
-  bool visible = browser_view_->IsToolbarVisible();
-  toolbar_->location_bar()->SetFocusable(visible);
+  bool toolbar_visible = browser_view_->IsToolbarVisible();
+  toolbar_->location_bar()->SetFocusable(toolbar_visible);
   int y = top;
   if (!browser_view_->UseVerticalTabs()) {
-    y -= ((visible && browser_view_->IsTabStripVisible()) ?
-          kToolbarTabStripVerticalOverlap : 0);
+    y -= ((toolbar_visible || browser_view_->UseCompactNavigationBar()) &&
+           browser_view_->IsTabStripVisible()) ?
+           kToolbarTabStripVerticalOverlap : 0;
   }
-  int height = visible ? toolbar_->GetPreferredSize().height() : 0;
-  toolbar_->SetVisible(visible);
+  int height = toolbar_visible ? toolbar_->GetPreferredSize().height() : 0;
+  toolbar_->SetVisible(toolbar_visible);
   toolbar_->SetBounds(vertical_layout_rect_.x(), y, browser_view_width, height);
+
+  // The spacer essentially replaces the toolbar when in compact mode.
+  if (browser_view_->UseCompactNavigationBar()) {
+    spacer_->SetVisible(!toolbar_visible);
+    spacer_->SetBounds(vertical_layout_rect_.x(), y, browser_view_width,
+                       toolbar_visible ? 0 : kCompactNavbarSpacerHeight);
+    height = kCompactNavbarSpacerHeight;
+  }
+
   return y + height;
 }
 
 int BrowserViewLayout::LayoutBookmarkAndInfoBars(int top) {
   find_bar_y_ = top + browser_view_->y() - 1;
   if (active_bookmark_bar_) {
     // If we're showing the Bookmark bar in detached style, then we
     // need to show any Info bar _above_ the Bookmark bar, since the
     // Bookmark bar is styled to look like it's part of the page.
     if (active_bookmark_bar_->IsDetached())
       return LayoutBookmarkBar(LayoutInfoBar(top));
     // Otherwise, Bookmark bar first, Info bar second.
     top = std::max(toolbar_->bounds().bottom(), LayoutBookmarkBar(top));
   }
   find_bar_y_ = top + browser_view_->y() - 1;
   return LayoutInfoBar(top);
 }
 
 int BrowserViewLayout::LayoutBookmarkBar(int top) {
   DCHECK(active_bookmark_bar_);
   int y = top;
   if (!browser_view_->IsBookmarkBarVisible()) {
     active_bookmark_bar_->SetVisible(false);
     active_bookmark_bar_->SetBounds(0, y, browser_view_->width(), 0);
     return y;
   }
 
   active_bookmark_bar_->set_infobar_visible(InfobarVisible());
   int bookmark_bar_height = active_bookmark_bar_->GetPreferredSize().height();
-  y -= views::NonClientFrameView::kClientEdgeThickness +
-      active_bookmark_bar_->GetToolbarOverlap(false);
+  if (!browser_view_->UseCompactNavigationBar()) {
+    y -= views::NonClientFrameView::kClientEdgeThickness +
+        active_bookmark_bar_->GetToolbarOverlap(false);
+  } else {
+    y -= kSpacerBookmarkBarOverlap;
+  }
   active_bookmark_bar_->SetVisible(true);
   active_bookmark_bar_->SetBounds(vertical_layout_rect_.x(), y,
                                   vertical_layout_rect_.width(),
                                   bookmark_bar_height);
   return y + bookmark_bar_height;
 }
 
 int BrowserViewLayout::LayoutInfoBar(int top) {
   // Raise the |infobar_container_| by its vertical overlap.
   infobar_container_->SetVisible(InfobarVisible());
@@ skipping 154 matching lines @@
     bottom -= height;
   }
   return bottom;
 }
 
 bool BrowserViewLayout::InfobarVisible() const {
   // NOTE: Can't check if the size IsEmpty() since it's always 0-width.
   return browser()->SupportsWindowFeature(Browser::FEATURE_INFOBAR) &&
       (infobar_container_->GetPreferredSize().height() != 0);
 }