Use the correct launcher assets for shelf alignment.

ash/launcher/launcher_view.cc

 // Copyright (c) 2012 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 "ash/launcher/launcher_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/launcher/app_list_button.h"
 #include "ash/launcher/launcher_button.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_icon_observer.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_tooltip_manager.h"
 #include "ash/launcher/overflow_bubble.h"
 #include "ash/launcher/overflow_button.h"
 #include "ash/launcher/tabbed_launcher_button.h"
-#include "ash/shell.h"
 #include "ash/shell_delegate.h"
+#include "ash/wm/shelf_layout_manager.h"
 #include "base/auto_reset.h"
 #include "base/memory/scoped_ptr.h"
 #include "grit/ash_strings.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animator.h"
@@ skipping 244 matching lines @@
       delegate_(delegate),
       view_model_(new views::ViewModel),
       first_visible_index_(0),
       last_visible_index_(-1),
       overflow_button_(NULL),
       drag_pointer_(NONE),
       drag_view_(NULL),
       drag_offset_(0),
       start_drag_index_(-1),
       context_menu_id_(0),
-      alignment_(SHELF_ALIGNMENT_BOTTOM),
       leading_inset_(kDefaultLeadingInset) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new LauncherFocusSearch(view_model_.get()));
   tooltip_.reset(new LauncherTooltipManager(
-      alignment_, shelf_layout_manager, this));
+      shelf_layout_manager, this));
 }
 
 LauncherView::~LauncherView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
 }
 
 void LauncherView::Init() {
   model_->AddObserver(this);
 
@@ skipping 13 matching lines @@
   AddChildView(overflow_button_);
 
   // We'll layout when our bounds change.
 }
 
 void LauncherView::SetAlignment(ShelfAlignment alignment) {
   if (alignment_ == alignment)
     return;
   alignment_ = alignment;
   UpdateFirstButtonPadding();
-  overflow_button_->SetShelfAlignment(alignment_);
+  overflow_button_->OnShelfAlignmentChanged();
   LayoutToIdealBounds();
-  tooltip_->SetArrowLocation(alignment_);
+  tooltip_->UpdateArrowLocation();
   if (overflow_bubble_.get())
     overflow_bubble_->Hide();
 }
 
 gfx::Rect LauncherView::GetIdealBoundsOfItemIcon(LauncherID id) {
   int index = model_->ItemIndexByID(id);
   if (index == -1 || index > last_visible_index_)
     return gfx::Rect();
   const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
   DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
@@ skipping 48 matching lines @@
 
   if (bounds_animator_->IsAnimating())
     AnimateToIdealBounds();
   else
     views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
 
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 void LauncherView::CalculateIdealBounds(IdealBounds* bounds) {
-  int available_size = primary_axis_coordinate(width(), height());
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
+  int available_size = shelf->PrimaryAxisValue(width(), height());
   if (!available_size)
     return;
 
   // Initial x,y values account both leading_inset in primary
   // coordinate and secondary coordinate based on the dynamic edge of the
   // launcher (eg top edge on bottom-aligned launcher).
-  int x = alignment_based_value(leading_inset(),
+  int x = shelf->SelectValueForShelfAlignment(
+      leading_inset(),
       width() - kLauncherPreferredSize,
       std::max(width() - kLauncherPreferredSize,
-          ShelfLayoutManager::kAutoHideSize + 1));
-  int y = primary_axis_coordinate(0, leading_inset());
+               ShelfLayoutManager::kAutoHideSize + 1));
+  int y = shelf->PrimaryAxisValue(0, leading_inset());
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
-    int w = primary_axis_coordinate(kLauncherPreferredSize, width());
-    int h = primary_axis_coordinate(height(), kLauncherPreferredSize);
+    int w = shelf->PrimaryAxisValue(kLauncherPreferredSize, width());
+    int h = shelf->PrimaryAxisValue(height(), kLauncherPreferredSize);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    x = primary_axis_coordinate(x + w + kButtonSpacing, x);
-    y = primary_axis_coordinate(y, y + h + kButtonSpacing);
+    x = shelf->PrimaryAxisValue(x + w + kButtonSpacing, x);
+    y = shelf->PrimaryAxisValue(y, y + h + kButtonSpacing);
   }
 
   int app_list_index = view_model_->view_size() - 1;
   if (is_overflow_mode()) {
     last_visible_index_ = app_list_index - 1;
     for (int i = 0; i < view_model_->view_size(); ++i) {
       view_model_->view_at(i)->SetVisible(
           i >= first_visible_index_ && i <= last_visible_index_);
     }
     return;
   }
 
   bounds->overflow_bounds.set_size(gfx::Size(
-      primary_axis_coordinate(kLauncherPreferredSize, width()),
-      primary_axis_coordinate(height(), kLauncherPreferredSize)));
+      shelf->PrimaryAxisValue(kLauncherPreferredSize, width()),
+      shelf->PrimaryAxisValue(height(), kLauncherPreferredSize)));
   last_visible_index_ = DetermineLastVisibleIndex(
       available_size - leading_inset() - kLauncherPreferredSize -
       kButtonSpacing - kLauncherPreferredSize);
   bool show_overflow = (last_visible_index_ + 1 < app_list_index);
 
   for (int i = 0; i < view_model_->view_size(); ++i) {
     view_model_->view_at(i)->SetVisible(
         i == app_list_index || i <= last_visible_index_);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
-      x = alignment_based_value(leading_inset(),
-              width() - kLauncherPreferredSize,
-              std::max(width() - kLauncherPreferredSize,
-                  ShelfLayoutManager::kAutoHideSize + 1));
-      y = primary_axis_coordinate(0, leading_inset());
+      x = shelf->SelectValueForShelfAlignment(
+          leading_inset(),
+          width() - kLauncherPreferredSize,
+          std::max(width() - kLauncherPreferredSize,
+                   ShelfLayoutManager::kAutoHideSize + 1));
+      y = shelf->PrimaryAxisValue(0, leading_inset());
     } else {
-      x = primary_axis_coordinate(
+      x = shelf->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).right(),
           view_model_->ideal_bounds(last_visible_index_).x());
-      y = primary_axis_coordinate(
+      y = shelf->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).y(),
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
     gfx::Rect app_list_bounds = view_model_->ideal_bounds(app_list_index);
     bounds->overflow_bounds.set_x(x);
     bounds->overflow_bounds.set_y(y);
-    x = primary_axis_coordinate(x + kLauncherPreferredSize + kButtonSpacing, x);
-    y = primary_axis_coordinate(y, y + kLauncherPreferredSize + kButtonSpacing);
+    x = shelf->PrimaryAxisValue(x + kLauncherPreferredSize + kButtonSpacing, x);
+    y = shelf->PrimaryAxisValue(y, y + kLauncherPreferredSize + kButtonSpacing);
     app_list_bounds.set_x(x);
     app_list_bounds.set_y(y);
     view_model_->set_ideal_bounds(app_list_index, app_list_bounds);
   } else {
     if (overflow_bubble_.get())
       overflow_bubble_->Hide();
   }
 }
 
 int LauncherView::DetermineLastVisibleIndex(int max_value) {
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
   int index = view_model_->view_size() - 1;
   while (index >= 0 &&
-         primary_axis_coordinate(
+         shelf->PrimaryAxisValue(
              view_model_->ideal_bounds(index).right(),
              view_model_->ideal_bounds(index).bottom()) > max_value) {
     index--;
   }
   return index;
 }
 
 void LauncherView::AddIconObserver(LauncherIconObserver* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 13 matching lines @@
 }
 
 views::View* LauncherView::CreateViewForItem(const LauncherItem& item) {
   views::View* view = NULL;
   switch (item.type) {
     case TYPE_TABBED: {
       TabbedLauncherButton* button =
           TabbedLauncherButton::Create(
               this,
               this,
+              tooltip_->shelf_layout_manager(),
               item.is_incognito ?
                   TabbedLauncherButton::STATE_INCOGNITO :
                   TabbedLauncherButton::STATE_NOT_INCOGNITO);
       button->SetTabImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_SHORTCUT:
     case TYPE_PLATFORM_APP:
     case TYPE_APP_PANEL: {
-      LauncherButton* button = LauncherButton::Create(this, this);
+      LauncherButton* button = LauncherButton::Create(
+          this, this, tooltip_->shelf_layout_manager());
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
       // TODO(dave): turn this into a LauncherButton too.
       AppListButton* button = new AppListButton(this, this);
       view = button;
       break;
     }
 
     case TYPE_BROWSER_SHORTCUT: {
       ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-      LauncherButton* button = LauncherButton::Create(this, this);
+      LauncherButton* button = LauncherButton::Create(
+          this, this, tooltip_->shelf_layout_manager());
       int image_id = delegate_ ?
           delegate_->GetBrowserShortcutResourceId() :
           IDR_AURA_LAUNCHER_BROWSER_SHORTCUT;
       button->SetImage(*rb.GetImageNamed(image_id).ToImageSkia());
       view = button;
       break;
     }
 
     default:
       break;
@@ skipping 27 matching lines @@
     CancelDrag(-1);
     return;
   }
 
   // Move the view to the front so that it appears on top of other views.
   ReorderChildView(drag_view_, -1);
   bounds_animator_->StopAnimatingView(drag_view_);
 }
 
 void LauncherView::ContinueDrag(const ui::LocatedEvent& event) {
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
   // TODO: I don't think this works correctly with RTL.
   gfx::Point drag_point(event.location());
   views::View::ConvertPointToTarget(drag_view_, this, &drag_point);
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
 
   // If the item is no longer draggable, bail out.
   if (current_index == -1 ||
       !delegate_->IsDraggable(model_->items()[current_index])) {
     CancelDrag(-1);
     return;
   }
 
   // Constrain the location to the range of valid indices for the type.
   std::pair<int, int> indices(GetDragRange(current_index));
   int last_drag_index = indices.second;
   // If the last index isn't valid, we're overflowing. Constrain to the app list
   // (which is the last visible item).
   if (last_drag_index > last_visible_index_)
     last_drag_index = last_visible_index_;
   int x = 0, y = 0;
-  if (is_horizontal_alignment()) {
+  if (shelf->IsHorizontalAlignment()) {
     x = std::max(view_model_->ideal_bounds(indices.first).x(),
                      drag_point.x() - drag_offset_);
     x = std::min(view_model_->ideal_bounds(last_drag_index).right() -
                  view_model_->ideal_bounds(current_index).width(),
                  x);
     if (drag_view_->x() == x)
       return;
     drag_view_->SetX(x);
   } else {
     y = std::max(view_model_->ideal_bounds(indices.first).y(),
                      drag_point.y() - drag_offset_);
     y = std::min(view_model_->ideal_bounds(last_drag_index).bottom() -
                  view_model_->ideal_bounds(current_index).height(),
                  y);
     if (drag_view_->y() == y)
       return;
     drag_view_->SetY(y);
   }
 
   int target_index =
       views::ViewModelUtils::DetermineMoveIndex(
           *view_model_, drag_view_,
-          is_horizontal_alignment() ?
+          shelf->IsHorizontalAlignment() ?
               views::ViewModelUtils::HORIZONTAL :
               views::ViewModelUtils::VERTICAL,
           x, y);
   target_index =
       std::min(indices.second, std::max(target_index, indices.first));
   if (target_index == current_index)
     return;
 
   // Change the model, the LauncherItemMoved() callback will handle the
   // |view_model_| update.
@@ skipping 41 matching lines @@
 void LauncherView::ShowOverflowBubble() {
   int first_overflow_index = last_visible_index_ + 1;
   DCHECK_LT(first_overflow_index, view_model_->view_size() - 1);
 
   if (!overflow_bubble_.get())
     overflow_bubble_.reset(new OverflowBubble());
 
   overflow_bubble_->Show(delegate_,
                          model_,
                          overflow_button_,
-                         alignment_,
                          first_overflow_index);
 
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
 void LauncherView::UpdateFirstButtonPadding() {
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
   // Creates an empty border for first launcher button to make included leading
   // inset act as the button's padding. This is only needed on button creation
   // and when shelf alignment changes.
   if (view_model_->view_size() > 0) {
     view_model_->view_at(0)->set_border(views::Border::CreateEmptyBorder(
-        primary_axis_coordinate(0, leading_inset()),
-        primary_axis_coordinate(leading_inset(), 0),
+        shelf->PrimaryAxisValue(0, leading_inset()),
+        shelf->PrimaryAxisValue(leading_inset(), 0),
         0,
         0));
   }
 }
 
 bool LauncherView::ShouldHideTooltip(const gfx::Point& cursor_location) {
   gfx::Rect active_bounds;
 
   for (int i = 0; i < child_count(); ++i) {
     views::View* child = child_at(i);
@@ skipping 39 matching lines @@
 
   const int app_list_index = view_model_->view_size() - 1;
   const int last_button_index = is_overflow_mode() ?
       last_visible_index_ : app_list_index;
   const gfx::Rect last_button_bounds =
       last_button_index  >= first_visible_index_ ?
           view_model_->view_at(last_button_index)->bounds() :
           gfx::Rect(gfx::Size(kLauncherPreferredSize,
                               kLauncherPreferredSize));
 
-  if (is_horizontal_alignment()) {
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
+  if (shelf->IsHorizontalAlignment()) {
     return gfx::Size(last_button_bounds.right() + leading_inset(),
                      kLauncherPreferredSize);
   }
 
   return gfx::Size(kLauncherPreferredSize,
                    last_button_bounds.bottom() + leading_inset());
 }
 
 void LauncherView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   LayoutToIdealBounds();
@@ skipping 124 matching lines @@
   if (drag_view_)
     return;
 
   tooltip_->Close();
   int index = view_model_->GetIndexOfView(view);
   if (index == -1 ||
       view_model_->view_size() <= 1 ||
       !delegate_->IsDraggable(model_->items()[index]))
     return;  // View is being deleted or not draggable, ignore request.
 
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
+
   drag_view_ = view;
-  drag_offset_ = primary_axis_coordinate(event.x(), event.y());
+  drag_offset_ = shelf->PrimaryAxisValue(event.x(), event.y());
 }
 
 void LauncherView::PointerDraggedOnButton(views::View* view,
                                           Pointer pointer,
                                           const ui::LocatedEvent& event) {
+  ShelfLayoutManager* shelf = tooltip_->shelf_layout_manager();
   if (!dragging() && drag_view_ &&
-      primary_axis_coordinate(abs(event.x() - drag_offset_),
+      shelf->PrimaryAxisValue(abs(event.x() - drag_offset_),
                               abs(event.y() - drag_offset_)) >=
       kMinimumDragDistance) {
     PrepareForDrag(pointer, event);
   }
   if (drag_pointer_ == pointer)
     ContinueDrag(event);
 }
 
 void LauncherView::PointerReleasedOnButton(views::View* view,
                                            Pointer pointer,
@@ skipping 30 matching lines @@
   } else {
     tooltip_->ShowDelayed(view, GetAccessibleName(view));
   }
 }
 
 void LauncherView::MouseExitedButton(views::View* view) {
   if (!tooltip_->IsVisible())
     tooltip_->StopTimer();
 }
 
-ShelfAlignment LauncherView::GetShelfAlignment() const {
-  return alignment_;
-}
-
 string16 LauncherView::GetAccessibleName(const views::View* view) {
   int view_index = view_model_->GetIndexOfView(view);
   // May be -1 while in the process of animating closed.
   if (view_index == -1)
     return string16();
 
   switch (model_->items()[view_index].type) {
     case TYPE_TABBED:
     case TYPE_APP_PANEL:
     case TYPE_APP_SHORTCUT:
@@ skipping 100 matching lines @@
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
                     OnLauncherIconPositionsChanged());
   PreferredSizeChanged();
 }
 
 void LauncherView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
 }
 
 }  // namespace internal
 }  // namespace ash