Align panel icons on the right / end.

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"
@@ skipping 292 matching lines @@
 
   const LauncherItems& items(model_->items());
   for (LauncherItems::const_iterator i = items.begin(); i != items.end(); ++i) {
     views::View* child = CreateViewForItem(*i);
     child->SetPaintToLayer(true);
     view_model_->Add(child, static_cast<int>(i - items.begin()));
     AddChildView(child);
   }
   UpdateFirstButtonPadding();
   LauncherStatusChanged();
-
   overflow_button_ = new OverflowButton(this);
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   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_);
   LayoutToIdealBounds();
   tooltip_->SetArrowLocation(alignment_);
   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_)
+  if (index == -1 || (index > last_visible_index_ &&
+                      index < model_->FirstPanelIndex()))
     return gfx::Rect();
   const gfx::Rect& ideal_bounds(view_model_->ideal_bounds(index));
   DCHECK_NE(TYPE_APP_LIST, model_->items()[index].type);
   LauncherButton* button =
       static_cast<LauncherButton*>(view_model_->view_at(index));
   gfx::Rect icon_bounds = button->GetIconBounds();
   return gfx::Rect(ideal_bounds.x() + icon_bounds.x(),
                    ideal_bounds.y() + icon_bounds.y(),
                    icon_bounds.width(), icon_bounds.height());
 }
@@ skipping 42 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());
+  int first_panel_index = model_->FirstPanelIndex();
   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(),
       width() - kLauncherPreferredSize,
       std::max(width() - kLauncherPreferredSize,
           ShelfLayoutManager::kAutoHideSize + 1));
   int y = primary_axis_coordinate(0, leading_inset());
-  for (int i = 0; i < view_model_->view_size(); ++i) {
+  int w = primary_axis_coordinate(kLauncherPreferredSize, width());
+  int h = primary_axis_coordinate(height(), kLauncherPreferredSize);
+  for (int i = 0; i < first_panel_index; ++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);
     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);
   }
 
-  int app_list_index = view_model_->view_size() - 1;
+  int app_list_index = first_panel_index - 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;
   }
 
+  // Right aligned icons.
+  // TODO(flackr): The right aligned icons may not fit in the launcher in which
+  // case they should be moved to an overflow bubble. See
+  // http://crbug.com/162558 for panel overflow details.
+  int end_position = available_size - kButtonSpacing;
+  x = primary_axis_coordinate(end_position, leading_inset());
+  y = primary_axis_coordinate(0, end_position);
+  for (int i = view_model_->view_size() - 1;
+       i >= first_panel_index; --i) {
+    x = primary_axis_coordinate(x - w - kButtonSpacing, x);
+    y = primary_axis_coordinate(y, y - h - kButtonSpacing);
+    view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
+    end_position = primary_axis_coordinate(x, y);
+  }
+
   bounds->overflow_bounds.set_size(gfx::Size(
       primary_axis_coordinate(kLauncherPreferredSize, width()),
       primary_axis_coordinate(height(), kLauncherPreferredSize)));
   last_visible_index_ = DetermineLastVisibleIndex(
-      available_size - leading_inset() - kLauncherPreferredSize -
-      kButtonSpacing - kLauncherPreferredSize);
+      end_position - leading_inset() - 2 * 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_);
+        i <= last_visible_index_ || i >= app_list_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));
@@ skipping 141 matching lines @@
 
   // 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 first_drag_index = indices.first;
   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_)
+  if (first_drag_index < model_->FirstPanelIndex() &&
+      last_drag_index > last_visible_index_)
     last_drag_index = last_visible_index_;
   int x = 0, y = 0;
   if (is_horizontal_alignment()) {
     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;
@@ skipping 24 matching lines @@
   // Change the model, the LauncherItemMoved() callback will handle the
   // |view_model_| update.
   model_->Move(current_index, target_index);
   bounds_animator_->StopAnimatingView(drag_view_);
 }
 
 bool LauncherView::SameDragType(LauncherItemType typea,
                                 LauncherItemType typeb) const {
   switch (typea) {
     case TYPE_TABBED:
-    case TYPE_APP_PANEL:
     case TYPE_PLATFORM_APP:
-      return (typeb == TYPE_TABBED ||
-          typeb == TYPE_APP_PANEL ||
-          typeb == TYPE_PLATFORM_APP);
+      return (typeb == TYPE_TABBED || typeb == TYPE_PLATFORM_APP);
     case TYPE_APP_SHORTCUT:
     case TYPE_APP_LIST:
+    case TYPE_APP_PANEL:
     case TYPE_BROWSER_SHORTCUT:
       return typeb == typea;
   }
   NOTREACHED();
   return false;
 }
 
 std::pair<int, int> LauncherView::GetDragRange(int index) {
   int min_index = -1;
   int max_index = -1;
@@ skipping 138 matching lines @@
   // spot (because it was in the middle of animating from 0,0 0x0 to its
   // target).
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   view->SetBoundsRect(view_model_->ideal_bounds(model_index));
 
   // The first animation moves all the views to their target position. |view|
   // is hidden, so it visually appears as though we are providing space for
   // it. When done we'll fade the view in.
   AnimateToIdealBounds();
-  if (model_index <= last_visible_index_) {
+  if (model_index <= last_visible_index_ ||
+      model_index >= model_->FirstPanelIndex()) {
     bounds_animator_->SetAnimationDelegate(
         view, new StartFadeAnimationDelegate(this, view), true);
   } else {
     // Undo the hiding if animation does not run.
     view->layer()->SetOpacity(1.0f);
   }
 }
 
 void LauncherView::LauncherItemRemoved(int model_index, LauncherID id) {
 #if !defined(OS_MACOSX)
@@ skipping 258 matching lines @@
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
                     OnLauncherIconPositionsChanged());
   PreferredSizeChanged();
 }
 
 void LauncherView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
 }
 
 }  // namespace internal
 }  // namespace ash