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 258 matching lines @@
 };
 
 LauncherView::LauncherView(LauncherModel* model,
                            LauncherDelegate* delegate,
                            ShelfLayoutManager* shelf_layout_manager)
     : model_(model),
       delegate_(delegate),
       view_model_(new views::ViewModel),
       first_visible_index_(0),
       last_visible_index_(-1),
+      end_align_index_(0),
       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));
 }
 
 LauncherView::~LauncherView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
 }
 
 void LauncherView::Init() {
   model_->AddObserver(this);
 
+  end_align_index_ = model_->EndAlignedIndex();
   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_);
+  AddChildViewAt(overflow_button_, end_align_index_);
 
   // 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 < end_align_index_))
     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 53 matching lines @@
     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 < end_align_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;
+  // Right aligned icons
+  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 >= end_align_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);
+  }
+
+  int app_list_index = end_align_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;
   }
 
   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 < end_align_index_ &&
+      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);

[stevenjb, 2012/11/26 18:19:21]

nit: one line?

[flackr, 2012/11/27 18:40:21]

Done.

     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 125 matching lines @@
 
 void LauncherView::LauncherItemAdded(int model_index) {
   model_index = CancelDrag(model_index);
   views::View* view = CreateViewForItem(model_->items()[model_index]);
   AddChildView(view);
   // Hide the view, it'll be made visible when the animation is done. Using
   // opacity 0 here to avoid messing with CalculateIdealBounds which touches
   // the view's visibility.
   view->layer()->SetOpacity(0);
   view_model_->Add(view, model_index);
+  end_align_index_ = model_->EndAlignedIndex();
 
   // Give the button its ideal bounds. That way if we end up animating the
   // button before this animation completes it doesn't appear at some random
   // 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 >= end_align_index_) {
     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)
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
 #endif
   model_index = CancelDrag(model_index);
   views::View* view = view_model_->view_at(model_index);
   view_model_->Remove(model_index);
+  end_align_index_ = model_->EndAlignedIndex();
   // The first animation fades out the view. When done we'll animate the rest of
   // the views to their target location.
   bounds_animator_->AnimateViewTo(view, view->bounds());
   bounds_animator_->SetAnimationDelegate(
       view, new FadeOutAnimationDelegate(this, view), true);
 }
 
 void LauncherView::LauncherItemChanged(int model_index,
                                        const ash::LauncherItem& old_item) {
   const LauncherItem& item(model_->items()[model_index]);
@@ skipping 242 matching lines @@
   FOR_EACH_OBSERVER(LauncherIconObserver, observers_,
                     OnLauncherIconPositionsChanged());
   PreferredSizeChanged();
 }
 
 void LauncherView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
 }
 
 }  // namespace internal
 }  // namespace ash