Rename Launcher to Shelf.

ash/shelf/shelf_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/shelf/shelf_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
@@ skipping 69 matching lines @@
 // Size allocated to for each button.
 const int kButtonSize = 44;
 
 // Additional spacing for the left and right side of icons.
 const int kHorizontalIconSpacing = 2;
 
 // Inset for items which do not have an icon.
 const int kHorizontalNoIconInsetSpacing =
     kHorizontalIconSpacing + kDefaultLeadingInset;
 
-// The proportion of the launcher space reserved for non-panel icons. Panels
+// The proportion of the shelf space reserved for non-panel icons. Panels
 // may flow into this space but will be put into the overflow bubble if there
 // is contention for the space.
 const float kReservedNonPanelIconProportion = 0.67f;
 
 // This is the command id of the menu item which contains the name of the menu.
 const int kCommandIdOfMenuName = 0;
 
 // The background color of the active item in the list.
 const SkColor kActiveListItemBackgroundColor = SkColorSetRGB(203 , 219, 241);
 
@@ skipping 95 matching lines @@
 }
 
 int ShelfMenuModelAdapter::GetMaxWidthForMenu(views::MenuItemView* menu) {
   return kMaximumAppMenuItemLength;
 }
 
 bool ShelfMenuModelAdapter::ShouldReserveSpaceForSubmenuIndicator() const {
   return false;
 }
 
-// Custom FocusSearch used to navigate the launcher in the order items are in
+// Custom FocusSearch used to navigate the shelf in the order items are in
 // the ViewModel.
-class LauncherFocusSearch : public views::FocusSearch {
+class ShelfFocusSearch : public views::FocusSearch {
  public:
-  explicit LauncherFocusSearch(views::ViewModel* view_model)
+  explicit ShelfFocusSearch(views::ViewModel* view_model)
       : FocusSearch(NULL, true, true),
         view_model_(view_model) {}
-  virtual ~LauncherFocusSearch() {}
+  virtual ~ShelfFocusSearch() {}
 
   // views::FocusSearch overrides:
   virtual View* FindNextFocusableView(
       View* starting_view,
       bool reverse,
       Direction direction,
       bool check_starting_view,
       views::FocusTraversable** focus_traversable,
       View** focus_traversable_view) OVERRIDE {
     int index = view_model_->GetIndexOfView(starting_view);
     if (index == -1)
       return view_model_->view_at(0);
 
     if (reverse) {
       --index;
       if (index < 0)
         index = view_model_->view_size() - 1;
     } else {
       ++index;
       if (index >= view_model_->view_size())
         index = 0;
     }
     return view_model_->view_at(index);
   }
 
  private:
   views::ViewModel* view_model_;
 
-  DISALLOW_COPY_AND_ASSIGN(LauncherFocusSearch);
+  DISALLOW_COPY_AND_ASSIGN(ShelfFocusSearch);
 };
 
 // AnimationDelegate used when inserting a new item. This steadily increases the
 // opacity of the layer as the animation progress.
 class FadeInAnimationDelegate
     : public views::BoundsAnimator::OwnedAnimationDelegate {
  public:
   explicit FadeInAnimationDelegate(views::View* view) : view_(view) {}
   virtual ~FadeInAnimationDelegate() {}
 
@@ skipping 125 matching lines @@
       snap_back_from_rip_off_view_(NULL),
       item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       layout_manager_(manager),
       overflow_mode_(false),
       main_shelf_(NULL),
       dragged_off_from_overflow_to_shelf_(false) {
   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()));
+  focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
   tooltip_.reset(new ShelfTooltipManager(manager, this));
 }
 
 ShelfView::~ShelfView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
   // If we are inside the MenuRunner, we need to know if we were getting
   // deleted while it was running.
   if (got_deleted_)
     *got_deleted_ = true;
@@ skipping 179 matching lines @@
     return false;
 
   // If the AppsGridView (which was dispatching this event) was opened by our
   // button, ShelfView dragging operations are locked and we have to unlock.
   CancelDrag(-1);
   drag_and_drop_item_pinned_ = false;
   drag_and_drop_app_id_ = app_id;
   drag_and_drop_launcher_id_ =
       delegate_->GetLauncherIDForAppID(drag_and_drop_app_id_);
   // Check if the application is known and pinned - if not, we have to pin it so
-  // that we can re-arrange the launcher order accordingly. Note that items have
+  // that we can re-arrange the shelf order accordingly. Note that items have
   // to be pinned to give them the same (order) possibilities as a shortcut.
   // When an item is dragged from overflow to shelf, IsShowingOverflowBubble()
   // returns true. At this time, we don't need to pin the item.
   if (!IsShowingOverflowBubble() &&
       (!drag_and_drop_launcher_id_ ||
        !delegate_->IsAppPinned(app_id))) {
     delegate_->PinAppWithID(app_id);
     drag_and_drop_launcher_id_ =
         delegate_->GetLauncherIDForAppID(drag_and_drop_app_id_);
     if (!drag_and_drop_launcher_id_)
@@ skipping 110 matching lines @@
   int available_size = layout_manager_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   // 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).
+  // shelf (eg top edge on bottom-aligned shelf).
   int inset = ash::switches::UseAlternateShelfLayout() ? 0 : leading_inset_;
   int x = layout_manager_->SelectValueForShelfAlignment(inset, 0, 0, inset);
   int y = layout_manager_->SelectValueForShelfAlignment(0, inset, inset, 0);
 
   int button_size = GetButtonSize();
   int button_spacing = GetButtonSpacing();
 
   int w = layout_manager_->PrimaryAxisValue(button_size, width());
   int h = layout_manager_->PrimaryAxisValue(height(), button_size);
   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;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
     if (i != last_button_index) {
       x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
       y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
     }
   }
 
   if (is_overflow_mode()) {
     UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
-  // To address Fitt's law, we make the first launcher button include the
+  // To address Fitt's law, we make the first shelf button include the
   // leading inset (if there is one).
   if (!ash::switches::UseAlternateShelfLayout()) {
     if (view_model_->view_size() > 0) {
       view_model_->set_ideal_bounds(0, gfx::Rect(gfx::Size(
           layout_manager_->PrimaryAxisValue(inset + w, w),
           layout_manager_->PrimaryAxisValue(h, inset + h))));
     }
   }
 
   // Right aligned icons.
@@ skipping 295 matching lines @@
           *view_model_, drag_view_,
           layout_manager_->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
+  // Change the model, the ShelfItemMoved() callback will handle the
   // |view_model_| update.
   model_->Move(current_index, target_index);
   bounds_animator_->StopAnimatingView(drag_view_);
 }
 
 bool ShelfView::HandleRipOffDrag(const ui::LocatedEvent& event) {
   int current_index = view_model_->GetIndexOfView(drag_view_);
   DCHECK_NE(-1, current_index);
   std::string dragged_app_id =
       delegate_->GetAppIDForLauncherID(model_->items()[current_index].id);
@@ skipping 62 matching lines @@
     ShelfButton* button = static_cast<ShelfButton*>(drag_view_);
     CreateDragIconProxy(event.root_location(),
                         button->GetImage(),
                         drag_view_,
                         gfx::Vector2d(0, 0),
                         kDragAndDropProxyScale);
     drag_view_->layer()->SetOpacity(0.0f);
     dragged_off_shelf_ = true;
     if (RemovableByRipOff(current_index) == REMOVABLE) {
       // Move the item to the front of the first panel item and hide it.
-      // LauncherItemMoved() callback will handle the |view_model_| update and
+      // ShelfItemMoved() callback will handle the |view_model_| update and
       // call AnimateToIdealBounds().
       if (current_index != model_->FirstPanelIndex() - 1) {
         model_->Move(current_index, model_->FirstPanelIndex() - 1);
         StartFadeInLastVisibleItem();
       } else if (is_overflow_mode()) {
         // Overflow bubble should be shrunk when an item is ripped off.
         PreferredSizeChanged();
       }
       // Make the item partially disappear to show that it will get removed if
       // dropped.
@@ skipping 142 matching lines @@
 
   overflow_bubble_->Show(overflow_button_, overflow_view);
 
   Shell::GetInstance()->UpdateShelfVisibility();
 }
 
 void ShelfView::UpdateFirstButtonPadding() {
   if (ash::switches::UseAlternateShelfLayout())
     return;
 
-  // Creates an empty border for first launcher button to make included leading
+  // Creates an empty border for first shelf 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(
         layout_manager_->PrimaryAxisValue(0, leading_inset_),
         layout_manager_->PrimaryAxisValue(leading_inset_, 0),
         0,
         0));
   }
 }
@@ skipping 230 matching lines @@
   {
     base::AutoReset<bool> cancelling_drag(
         &cancelling_drag_model_changed_, true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = view_model_->view_at(model_index);
   view_model_->Remove(model_index);
 
   // When the overflow bubble is visible, the overflow range needs to be set
   // before CalculateIdealBounds() gets called. Otherwise CalculateIdealBounds()
-  // could trigger a LauncherItemChanged() by hiding the overflow bubble and
+  // could trigger a ShelfItemChanged() by hiding the overflow bubble and
   // since the overflow bubble is not yet synced with the ShelfModel this
   // could cause a crash.
   if (overflow_bubble_ && overflow_bubble_->IsShowing()) {
     last_hidden_index_ = std::min(last_hidden_index_,
                                   view_model_->view_size() - 1);
     UpdateOverflowRange(overflow_bubble_->shelf_view());
   }
 
   if (view->visible()) {
     // The first animation fades out the view. When done we'll animate the rest
@@ skipping 53 matching lines @@
       break;
     }
 
     default:
       break;
   }
 }
 
 void ShelfView::ShelfItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
-  // When cancelling a drag due to a launcher item being added, the currently
+  // When cancelling a drag due to a shelf item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
 void ShelfView::ShelfStatusChanged() {
   if (ash::switches::UseAlternateShelfLayout())
     return;
@@ skipping 222 matching lines @@
       new views::MenuRunner(menu_model_adapter->CreateMenu()));
 
   ScopedTargetRootWindow scoped_target(
       source->GetWidget()->GetNativeView()->GetRootWindow());
 
   // Determine the menu alignment dependent on the shelf.
   views::MenuItemView::AnchorPosition menu_alignment =
       views::MenuItemView::TOPLEFT;
   gfx::Rect anchor_point = gfx::Rect(click_point, gfx::Size());
 
-  ShelfWidget* shelf = RootWindowController::ForLauncher(
+  ShelfWidget* shelf = RootWindowController::ForShelf(
       GetWidget()->GetNativeView())->shelf();
   if (!context_menu) {
     // Application lists use a bubble.
     ash::ShelfAlignment align = shelf->GetAlignment();
     anchor_point = source->GetBoundsInScreen();
 
     // It is possible to invoke the menu while it is sliding into view. To cover
     // that case, the screen coordinates are offsetted by the animation delta.
     gfx::Vector2d offset =
         source->GetWidget()->GetNativeWindow()->bounds().origin() -
@@ skipping 14 matching lines @@
         menu_alignment = views::MenuItemView::BUBBLE_RIGHT;
         break;
       case ash::SHELF_ALIGNMENT_RIGHT:
         menu_alignment = views::MenuItemView::BUBBLE_LEFT;
         break;
       case ash::SHELF_ALIGNMENT_TOP:
         menu_alignment = views::MenuItemView::BUBBLE_BELOW;
         break;
     }
   }
-  // If this gets deleted while we are in the menu, the launcher will be gone
+  // If this gets deleted while we are in the menu, the shelf will be gone
   // as well.
   bool got_deleted = false;
   got_deleted_ = &got_deleted;
 
   shelf->ForceUndimming(true);
   // NOTE: if you convert to HAS_MNEMONICS be sure and update menu building
   // code.
   if (launcher_menu_runner_->RunMenuAt(
           source->GetWidget(),
           NULL,
@@ skipping 75 matching lines @@
     return false;
   const LauncherItem* item = LauncherItemForView(view);
   if (!item)
     return true;
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(item->id);
   return item_delegate->ShouldShowTooltip();
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
-  ShelfWidget* shelf = RootWindowController::ForLauncher(
+  ShelfWidget* shelf = RootWindowController::ForShelf(
       GetWidget()->GetNativeView())->shelf();
   ash::ShelfAlignment align = shelf->GetAlignment();
   const gfx::Rect bounds = GetBoundsInScreen();
   int distance = 0;
   switch (align) {
     case ash::SHELF_ALIGNMENT_BOTTOM:
       distance = bounds.y() - coordinate.y();
       break;
     case ash::SHELF_ALIGNMENT_LEFT:
       distance = coordinate.x() - bounds.right();
       break;
     case ash::SHELF_ALIGNMENT_RIGHT:
       distance = bounds.x() - coordinate.x();
       break;
     case ash::SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace internal
 }  // namespace ash