Location bar layout changes for M6 theme.

chrome/browser/views/location_bar/location_bar_view.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/location_bar/location_bar_view.h"
 
 #if defined(OS_LINUX)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 24 matching lines @@
 #include "grit/theme_resources.h"
 #include "views/drag_utils.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/views/first_run_bubble.h"
 #endif
 
 using views::View;
 
 // static
-const int LocationBarView::kVertMargin = 2;
-const int LocationBarView::kEdgeThickness = 2;
+const int LocationBarView::kNormalHorizontalEdgeThickness = 1;
+const int LocationBarView::kVerticalEdgeThickness = 2;
 const int LocationBarView::kItemPadding = 3;
+const int LocationBarView::kEdgeItemPadding = kItemPadding;
+const int LocationBarView::kBubblePadding = 1;
 const char LocationBarView::kViewClassName[] =
     "browser/views/location_bar/LocationBarView";
 
-// Convenience: Total space at the edges of the bar.
-const int kEdgePadding =
-    LocationBarView::kEdgeThickness + LocationBarView::kItemPadding;
-
-// Padding before the start of a bubble.
-static const int kBubblePadding = kEdgePadding - 1;
-
-// Padding between the location icon and the edit, if they're adjacent.
-static const int kLocationIconEditPadding = LocationBarView::kItemPadding - 1;
-
-// Padding after the star.
-static const int kStarPadding = kEdgePadding + 1;
-
 static const int kEVBubbleBackgroundImages[] = {
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_L,
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_C,
   IDR_OMNIBOX_EV_BUBBLE_BACKGROUND_R,
 };
 
 static const int kSelectedKeywordBackgroundImages[] = {
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_L,
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_C,
   IDR_LOCATION_BAR_SELECTED_KEYWORD_BACKGROUND_R,
@@ skipping 44 matching lines @@
   if (mode_ == POPUP) {
     font_ = ResourceBundle::GetSharedInstance().GetFont(
         ResourceBundle::BaseFont);
   } else {
     // Use a larger version of the system font.
     font_ = font_.DeriveFont(3);
   }
 
   // If this makes the font too big, try to make it smaller so it will fit.
   const int height =
-      std::max(GetPreferredSize().height() - TopMargin() - kVertMargin, 0);
+      std::max(GetPreferredSize().height() - (kVerticalEdgeThickness * 2), 0);
   while ((font_.height() > height) && (font_.FontSize() > 1))
     font_ = font_.DeriveFont(-1);
 
   location_icon_view_ = new LocationIconView(this);
   AddChildView(location_icon_view_);
   location_icon_view_->SetVisible(true);
   location_icon_view_->SetDragController(this);
 
   ev_bubble_view_ =
       new EVBubbleView(kEVBubbleBackgroundImages, IDR_OMNIBOX_HTTPS_VALID,
@@ skipping 27 matching lines @@
       l10n_util::GetStringUTF8(IDS_ACCNAME_LOCATION));
 #endif
   location_entry_view_ = new views::NativeViewHost;
   location_entry_view_->SetID(VIEW_ID_AUTOCOMPLETE);
   AddChildView(location_entry_view_);
   location_entry_view_->set_focus_view(this);
   location_entry_view_->Attach(location_entry_->GetNativeView());
   location_entry_view_->SetAccessibleName(
       l10n_util::GetString(IDS_ACCNAME_LOCATION));
 
-  selected_keyword_view_ =
-      new SelectedKeywordView(kSelectedKeywordBackgroundImages,
-                              IDR_OMNIBOX_SEARCH, SK_ColorBLACK, profile_),
+  selected_keyword_view_ = new SelectedKeywordView(
+      kSelectedKeywordBackgroundImages, IDR_KEYWORD_SEARCH_MAGNIFIER,
+      GetColor(ToolbarModel::NONE, TEXT), profile_),
   AddChildView(selected_keyword_view_);
   selected_keyword_view_->SetFont(font_);
   selected_keyword_view_->SetVisible(false);
 
   SkColor dimmed_text = GetColor(ToolbarModel::NONE, DEEMPHASIZED_TEXT);
 
   keyword_hint_view_ = new KeywordHintView(profile_);
   AddChildView(keyword_hint_view_);
   keyword_hint_view_->SetVisible(false);
   keyword_hint_view_->SetFont(font_);
@@ skipping 193 matching lines @@
 
 gfx::Size LocationBarView::GetPreferredSize() {
   return gfx::Size(0, GetThemeProvider()->GetBitmapNamed(mode_ == POPUP ?
       IDR_LOCATIONBG_POPUPMODE_CENTER : IDR_LOCATIONBG_C)->height());
 }
 
 void LocationBarView::Layout() {
   if (!location_entry_.get())
     return;
 
-  int entry_width = width() - (star_view_ ? kStarPadding : kEdgePadding);
+  // TODO(sky): baseline layout.
+  int location_y = kVerticalEdgeThickness;
+  int location_height = height() - (kVerticalEdgeThickness * 2);
+
+  // The edge stroke is 1 px thick.  In popup mode, the edges are drawn by the
+  // omnibox' parent, so there isn't any edge to account for at all.
+  const int kEdgeThickness = (mode_ == NORMAL) ?
+      kNormalHorizontalEdgeThickness : 0;
+  // The edit has 1 px of horizontal whitespace inside it before the text.
+  const int kEditInternalSpace = 1;
+  // The space between an item and the edit is the normal item space, minus the
+  // edit's built-in space (so the apparent space will be the same).
+  const int kItemEditPadding =
+      LocationBarView::kItemPadding - kEditInternalSpace;
+  const int kEdgeEditPadding =
+      LocationBarView::kEdgeItemPadding - kEditInternalSpace;
+
+  // Start by reserving the padding at the right edge.
+  int entry_width = width() - kEdgeThickness - kEdgeItemPadding;
 
   // |location_icon_view_| is visible except when |ev_bubble_view_| or
   // |selected_keyword_view_| are visible.
   int location_icon_width = 0;
   int ev_bubble_width = 0;
   location_icon_view_->SetVisible(false);
   ev_bubble_view_->SetVisible(false);
   const std::wstring keyword(location_entry_->model()->keyword());
   const bool is_keyword_hint(location_entry_->model()->is_keyword_hint());
   const bool show_selected_keyword = !keyword.empty() && !is_keyword_hint;
   if (show_selected_keyword) {
-    entry_width -= kEdgePadding;  // Assume the keyword might be hidden.
+    // Assume the keyword might be hidden.
+    entry_width -= (kEdgeThickness + kEdgeEditPadding);
   } else if (model_->GetSecurityLevel() == ToolbarModel::EV_SECURE) {
     ev_bubble_view_->SetVisible(true);
     ev_bubble_view_->SetLabel(model_->GetEVCertName());
     ev_bubble_width = ev_bubble_view_->GetPreferredSize().width();
     // We'll adjust this width and take it out of |entry_width| below.
   } else {
     location_icon_view_->SetVisible(true);
     location_icon_width = location_icon_view_->GetPreferredSize().width();
-    entry_width -=
-        kEdgePadding + location_icon_width + kLocationIconEditPadding;
+    entry_width -= (kEdgeThickness + kEdgeItemPadding + location_icon_width +
+        kItemEditPadding);
   }
 
   if (star_view_)
     entry_width -= star_view_->GetPreferredSize().width() + kItemPadding;
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
     if ((*i)->IsVisible())
-      entry_width -= (*i)->GetPreferredSize().width() + kItemPadding;
+      entry_width -= ((*i)->GetPreferredSize().width() + kItemPadding);
   }
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     if ((*i)->IsVisible())
-      entry_width -= (*i)->GetPreferredSize().width() + kItemPadding;
+      entry_width -= ((*i)->GetPreferredSize().width() + kItemPadding);
   }
+  // The gap between the edit and whatever is to its right is shortened.
+  entry_width += kEditInternalSpace;
 
   // Size the EV bubble.  We do this after taking the star/page actions/content
   // settings out of |entry_width| so we won't take too much space.
   if (ev_bubble_width) {
     // Try to elide the bubble to be no larger than half the total available
     // space, but never elide it any smaller than 150 px.
     static const int kMinElidedBubbleWidth = 150;
     static const double kMaxBubbleFraction = 0.5;
+    const int total_padding =
+        kEdgeThickness + kBubblePadding + kItemEditPadding;
     ev_bubble_width = std::min(ev_bubble_width, std::max(kMinElidedBubbleWidth,
-        static_cast<int>((entry_width - kBubblePadding - kItemPadding) *
-        kMaxBubbleFraction)));
-
-    entry_width -= kBubblePadding + ev_bubble_width + kItemPadding;
+        static_cast<int>((entry_width - total_padding) * kMaxBubbleFraction)));
+    entry_width -= (total_padding + ev_bubble_width);
   }
 
 #if defined(OS_WIN)
   RECT formatting_rect;
   location_entry_->GetRect(&formatting_rect);
   RECT edit_bounds;
   location_entry_->GetClientRect(&edit_bounds);
   int max_edit_width = entry_width - formatting_rect.left -
                        (edit_bounds.right - formatting_rect.right);
 #else
   int max_edit_width = entry_width;
 #endif
 
   if (max_edit_width < 0)
     return;
   const int available_width = AvailableWidth(max_edit_width);
 
   const bool show_keyword_hint = !keyword.empty() && is_keyword_hint;
   selected_keyword_view_->SetVisible(show_selected_keyword);
   keyword_hint_view_->SetVisible(show_keyword_hint);
   if (show_selected_keyword) {
     if (selected_keyword_view_->keyword() != keyword) {
       selected_keyword_view_->SetKeyword(keyword);
-
       const TemplateURL* template_url =
           profile_->GetTemplateURLModel()->GetTemplateURLForKeyword(keyword);
       if (template_url && template_url->IsExtensionKeyword()) {
         const SkBitmap& bitmap = profile_->GetExtensionsService()->
             GetOmniboxIcon(template_url->GetExtensionId());
         selected_keyword_view_->SetImage(bitmap);
       } else {
         selected_keyword_view_->SetImage(*ResourceBundle::GetSharedInstance().
             GetBitmapNamed(IDR_OMNIBOX_SEARCH));
       }
     }
   } else if (show_keyword_hint) {
     if (keyword_hint_view_->keyword() != keyword)
       keyword_hint_view_->SetKeyword(keyword);
   }
 
-  // TODO(sky): baseline layout.
-  int location_y = TopMargin();
-  int location_height = std::max(height() - location_y - kVertMargin, 0);
-
   // Lay out items to the right of the edit field.
-  int offset = width();
+  int offset = width() - kEdgeThickness - kEdgeItemPadding;
   if (star_view_) {
-    offset -= kStarPadding;
     int star_width = star_view_->GetPreferredSize().width();
     offset -= star_width;
     star_view_->SetBounds(offset, location_y, star_width, location_height);
     offset -= kItemPadding;
-  } else {
-    offset -= kEdgePadding;
   }
 
   for (PageActionViews::const_iterator i(page_action_views_.begin());
        i != page_action_views_.end(); ++i) {
     if ((*i)->IsVisible()) {
       int page_action_width = (*i)->GetPreferredSize().width();
       offset -= page_action_width;
       (*i)->SetBounds(offset, location_y, page_action_width, location_height);
       offset -= kItemPadding;
     }
   }
   // We use a reverse_iterator here because we're laying out the views from
   // right to left but in the vector they're ordered left to right.
   for (ContentSettingViews::const_reverse_iterator
        i(content_setting_views_.rbegin()); i != content_setting_views_.rend();
        ++i) {
     if ((*i)->IsVisible()) {
       int content_blocked_width = (*i)->GetPreferredSize().width();
       offset -= content_blocked_width;
       (*i)->SetBounds(offset, location_y, content_blocked_width,
                       location_height);
       offset -= kItemPadding;
     }
   }
 
   // Now lay out items to the left of the edit field.
   if (location_icon_view_->IsVisible()) {
-    location_icon_view_->SetBounds(kEdgePadding, location_y,
-                                   location_icon_width, location_height);
-    offset = location_icon_view_->bounds().right() + kLocationIconEditPadding;
+    location_icon_view_->SetBounds(kEdgeThickness + kEdgeItemPadding,
+        location_y, location_icon_width, location_height);
+    offset = location_icon_view_->bounds().right() + kItemEditPadding;
   } else if (ev_bubble_view_->IsVisible()) {
-    ev_bubble_view_->SetBounds(kBubblePadding, location_y, ev_bubble_width,
-                               location_height);
-    offset = ev_bubble_view_->bounds().right() + kItemPadding;
+    ev_bubble_view_->SetBounds(kEdgeThickness + kBubblePadding,
+        location_y + kBubblePadding, ev_bubble_width,
+        ev_bubble_view_->GetPreferredSize().height());
+    offset = ev_bubble_view_->bounds().right() + kItemEditPadding;
   } else {
-    offset = show_selected_keyword ? kBubblePadding : kEdgePadding;
+    offset = kEdgeThickness +
+        (show_selected_keyword ? kBubblePadding : kEdgeEditPadding);
   }
 
   // Now lay out the edit field and views that autocollapse to give it more
   // room.
   gfx::Rect location_bounds(offset, location_y, entry_width, location_height);
   if (show_selected_keyword) {
-    LayoutView(true, selected_keyword_view_, available_width, &location_bounds);
-    if (!selected_keyword_view_->IsVisible()) {
-      location_bounds.set_x(
-          location_bounds.x() + kEdgePadding - kBubblePadding);
+    selected_keyword_view_->SetBounds(0, location_y + kBubblePadding, 0,
+        selected_keyword_view_->GetPreferredSize().height());
+    LayoutView(selected_keyword_view_, kItemEditPadding, available_width,
+               true, &location_bounds);
+    location_bounds.set_x(selected_keyword_view_->IsVisible() ?
+        (offset + selected_keyword_view_->width() + kItemEditPadding) :
+        (kEdgeThickness + kEdgeEditPadding));
+  } else if (show_keyword_hint) {
+    keyword_hint_view_->SetBounds(0, location_y, 0, location_height);
+    // Tricky: |entry_width| has already been enlarged by |kEditInternalSpace|.
+    // But if we add a trailing view, it needs to have that enlargement be to
+    // its left.  So we undo the enlargement, then include it in the padding for
+    // the added view.
+    location_bounds.Inset(0, 0, kEditInternalSpace, 0);
+    LayoutView(keyword_hint_view_, kItemEditPadding, available_width, false,
+               &location_bounds);
+    if (!keyword_hint_view_->IsVisible()) {
+      // Put back the enlargement that we undid above.
+      location_bounds.Inset(0, 0, -kEditInternalSpace, 0);
     }
-  } else if (show_keyword_hint) {
-    LayoutView(false, keyword_hint_view_, available_width, &location_bounds);
   }
 
   location_entry_view_->SetBounds(location_bounds);
 }
 
 void LocationBarView::Paint(gfx::Canvas* canvas) {
   View::Paint(canvas);
 
   if (painter_.get()) {
     painter_->Paint(width(), height(), canvas);
   } else if (mode_ == POPUP) {
     canvas->TileImageInt(*GetThemeProvider()->GetBitmapNamed(
         IDR_LOCATIONBG_POPUPMODE_CENTER), 0, 0, 0, 0, width(), height());
   }
   // When used in the app launcher, don't draw a border, the LocationBarView has
   // its own views::Border.
 
   // Draw the background color so that the graphical elements at the edges
   // appear over the correct color.  (The edit draws its own background, so this
   // isn't important for that.)
   // TODO(pkasting): We need images that are transparent in the middle, so we
   // can draw the border images over the background color instead of the
   // reverse; this antialiases better (see comments in
   // AutocompletePopupContentsView::Paint()).
   gfx::Rect bounds(GetLocalBounds(false));
-  bounds.Inset(0, TopMargin(), 0, kVertMargin);
+  bounds.Inset(0, kVerticalEdgeThickness);
   SkColor color(GetColor(ToolbarModel::NONE, BACKGROUND));
   if (mode_ == NORMAL) {
     SkPaint paint;
     paint.setColor(color);
     paint.setStyle(SkPaint::kFill_Style);
     paint.setAntiAlias(true);
     // The round corners of the omnibox match the round corners of the dropdown
     // below, and all our other bubbles.
     const SkScalar radius(SkIntToScalar(BubbleBorder::GetCornerRadius()));
-    bounds.Inset(kEdgeThickness, 0);
+    bounds.Inset(kNormalHorizontalEdgeThickness, 0);
     canvas->AsCanvasSkia()->drawRoundRect(gfx::RectToSkRect(bounds), radius,
                                           radius, paint);
   } else {
     canvas->FillRectInt(color, bounds.x(), bounds.y(), bounds.width(),
                         bounds.height());
   }
 
   if (show_focus_rect_ && HasFocus()) {
     gfx::Rect r = location_entry_view_->bounds();
 #if defined(OS_WIN)
@@ skipping 121 matching lines @@
   DCHECK(delegate_->GetTabContents());
   return delegate_->GetTabContents()->GetFavIcon();
 }
 
 std::wstring LocationBarView::GetTitle() const {
   DCHECK(delegate_);
   DCHECK(delegate_->GetTabContents());
   return UTF16ToWideHack(delegate_->GetTabContents()->GetTitle());
 }
 
-int LocationBarView::TopMargin() const {
-  return std::min(kVertMargin, height());
-}
-
 int LocationBarView::AvailableWidth(int location_bar_width) {
 #if defined(OS_WIN)
   // Use font_.GetStringWidth() instead of
   // PosFromChar(location_entry_->GetTextLength()) because PosFromChar() is
   // apparently buggy. In both LTR UI and RTL UI with left-to-right layout,
   // PosFromChar(i) might return 0 when i is greater than 1.
   return std::max(
       location_bar_width - font_.GetStringWidth(location_entry_->GetText()), 0);
 #else
   return location_bar_width - location_entry_->TextWidth();
 #endif
 }
-
-bool LocationBarView::UsePref(int pref_width, int available_width) {
-  return (pref_width + kItemPadding <= available_width);
-}
-
-void LocationBarView::LayoutView(bool leading,
-                                 views::View* view,
+void LocationBarView::LayoutView(views::View* view,
+                                 int padding,
                                  int available_width,
+                                 bool leading,
                                  gfx::Rect* bounds) {
   DCHECK(view && bounds);
   gfx::Size view_size = view->GetPreferredSize();
-  if (!UsePref(view_size.width(), available_width))
+  if ((view_size.width() + padding) > available_width)
     view_size = view->GetMinimumSize();
-  if (view_size.width() + kItemPadding >= bounds->width()) {
-    view->SetVisible(false);
-    return;
+  int desired_width = view_size.width() + padding;
+  view->SetVisible(desired_width < bounds->width());
+  if (view->IsVisible()) {
+    view->SetBounds(
+        leading ? bounds->x() : (bounds->right() - view_size.width()),
+        view->y(), view_size.width(), view->height());
+    bounds->set_width(bounds->width() - desired_width);
   }
-  if (leading) {
-    view->SetBounds(bounds->x(), bounds->y(), view_size.width(),
-                    bounds->height());
-    bounds->Offset(view_size.width() + kItemPadding, 0);
-  } else {
-    view->SetBounds(bounds->right() - view_size.width(), bounds->y(),
-                    view_size.width(), bounds->height());
-  }
-  bounds->set_width(bounds->width() - view_size.width() - kItemPadding);
-  view->SetVisible(true);
 }
 
 void LocationBarView::RefreshContentSettingViews() {
   const TabContents* tab_contents = delegate_->GetTabContents();
   for (ContentSettingViews::const_iterator i(content_setting_views_.begin());
        i != content_setting_views_.end(); ++i) {
     (*i)->UpdateFromTabContents(
         model_->input_in_progress() ? NULL : tab_contents);
   }
 }
@@ skipping 86 matching lines @@
 
 void LocationBarView::ShowFirstRunBubbleInternal(
     FirstRun::BubbleType bubble_type) {
 #if defined(OS_WIN)  // First run bubble doesn't make sense for Chrome OS.
   // If the browser is no longer active, let's not show the info bubble, as this
   // would make the browser the active window again.
   if (!location_entry_view_ || !location_entry_view_->GetWidget()->IsActive())
     return;
 
   // Point at the start of the edit control; adjust to look as good as possible.
-  const int kXOffset = 6;   // Text looks like it actually starts 6 px in.
-  const int kYOffset = -4;  // Point into the omnibox, not just at its edge.
+  const int kXOffset = kNormalHorizontalEdgeThickness + kEdgeItemPadding +
+      ResourceBundle::GetSharedInstance().GetBitmapNamed(
+      IDR_OMNIBOX_HTTP)->width() + kItemPadding;
+  const int kYOffset = -(kVerticalEdgeThickness + 2);
   gfx::Point origin(location_entry_view_->bounds().x() + kXOffset,
                     y() + height() + kYOffset);
   // If the UI layout is RTL, the coordinate system is not transformed and
   // therefore we need to adjust the X coordinate so that bubble appears on the
   // right hand side of the location bar.
   if (base::i18n::IsRTL())
     origin.set_x(width() - origin.x());
   views::View::ConvertPointToScreen(this, &origin);
   FirstRunBubble::Show(profile_, GetWidget(), gfx::Rect(origin, gfx::Size()),
                        BubbleBorder::TOP_LEFT, bubble_type);
@@ skipping 160 matching lines @@
 
   NOTREACHED();
 }
 
 void LocationBarView::OnTemplateURLModelChanged() {
   template_url_model_->RemoveObserver(this);
   template_url_model_ = NULL;
   ShowFirstRunBubble(bubble_type_);
 }