Renames LauncherID, LauncherItem and LauncherItems...

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 276 matching lines @@
     view_->layer()->SetOpacity(1.0f);
     view_->layer()->ScheduleDraw();
   }
 
  private:
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(FadeInAnimationDelegate);
 };
 
-void ReflectItemStatus(const LauncherItem& item, ShelfButton* button) {
+void ReflectItemStatus(const ShelfItem& item, ShelfButton* button) {
   switch (item.status) {
     case STATUS_CLOSED:
       button->ClearState(ShelfButton::STATE_ACTIVE);
       button->ClearState(ShelfButton::STATE_RUNNING);
       button->ClearState(ShelfButton::STATE_ATTENTION);
       break;
     case STATUS_RUNNING:
       button->ClearState(ShelfButton::STATE_ACTIVE);
       button->AddState(ShelfButton::STATE_RUNNING);
       button->ClearState(ShelfButton::STATE_ATTENTION);
@@ skipping 82 matching lines @@
       drag_view_(NULL),
       drag_offset_(0),
       start_drag_index_(-1),
       context_menu_id_(0),
       leading_inset_(kDefaultLeadingInset),
       cancelling_drag_model_changed_(false),
       last_hidden_index_(0),
       closing_event_time_(base::TimeDelta()),
       got_deleted_(NULL),
       drag_and_drop_item_pinned_(false),
-      drag_and_drop_launcher_id_(0),
+      drag_and_drop_shelf_id_(0),
       dragged_off_shelf_(false),
       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 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;
 }
 
 void ShelfView::Init() {
   model_->AddObserver(this);
 
-  const LauncherItems& items(model_->items());
-  for (LauncherItems::const_iterator i = items.begin(); i != items.end(); ++i) {
+  const ShelfItems& items(model_->items());
+  for (ShelfItems::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);
   }
   ShelfStatusChanged();
   overflow_button_ = new OverflowButton(this);
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   AddChildView(overflow_button_);
@@ skipping 32 matching lines @@
 
 void ShelfView::SchedulePaintForAllButtons() {
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i >= first_visible_index_ && i <= last_visible_index_)
       view_model_->view_at(i)->SchedulePaint();
   }
   if (overflow_button_ && overflow_button_->visible())
     overflow_button_->SchedulePaint();
 }
 
-gfx::Rect ShelfView::GetIdealBoundsOfItemIcon(LauncherID id) {
+gfx::Rect ShelfView::GetIdealBoundsOfItemIcon(ShelfID id) {
   int index = model_->ItemIndexByID(id);
   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);
   ShelfButton* button = static_cast<ShelfButton*>(view_model_->view_at(index));
   gfx::Rect icon_bounds = button->GetIconBounds();
   return gfx::Rect(GetMirroredXWithWidthInView(
                        ideal_bounds.x() + icon_bounds.x(), icon_bounds.width()),
                    ideal_bounds.y() + icon_bounds.y(),
                    icon_bounds.width(),
                    icon_bounds.height());
 }
 
-void ShelfView::UpdatePanelIconPosition(LauncherID id,
+void ShelfView::UpdatePanelIconPosition(ShelfID id,
                                         const gfx::Point& midpoint) {
   int current_index = model_->ItemIndexByID(id);
   int first_panel_index = model_->FirstPanelIndex();
   if (current_index < first_panel_index)
     return;
 
   gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()),
                               midpoint.y());
   int target_index = current_index;
   while (target_index > first_panel_index &&
@@ skipping 81 matching lines @@
 
 void ShelfView::DestroyDragIconProxy() {
   drag_image_.reset();
   drag_image_offset_ = gfx::Vector2d(0, 0);
 }
 
 bool ShelfView::StartDrag(const std::string& app_id,
                           const gfx::Point& location_in_screen_coordinates) {
   // Bail if an operation is already going on - or the cursor is not inside.
   // This could happen if mouse / touch operations overlap.
-  if (drag_and_drop_launcher_id_ ||
+  if (drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     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_);
+  drag_and_drop_shelf_id_ =
+      delegate_->GetShelfIDForAppID(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 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_ ||
+      (!drag_and_drop_shelf_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_)
+    drag_and_drop_shelf_id_ =
+        delegate_->GetShelfIDForAppID(drag_and_drop_app_id_);
+    if (!drag_and_drop_shelf_id_)
       return false;
     drag_and_drop_item_pinned_ = true;
   }
   views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_launcher_id_));
+      model_->ItemIndexByID(drag_and_drop_shelf_id_));
   DCHECK(drag_and_drop_view);
 
   // Since there is already an icon presented by the caller, we hide this item
   // for now. That has to be done by reducing the size since the visibility will
   // change once a regrouping animation is performed.
   pre_drag_and_drop_size_ = drag_and_drop_view->size();
   drag_and_drop_view->SetSize(gfx::Size());
 
   // First we have to center the mouse cursor over the item.
   gfx::Point pt = drag_and_drop_view->GetBoundsInScreen().CenterPoint();
   views::View::ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root = location_in_screen_coordinates;
   ash::wm::ConvertPointFromScreen(
       ash::wm::GetRootWindowAt(location_in_screen_coordinates),
       &point_in_root);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, pt, point_in_root, 0, 0);
   PointerPressedOnButton(drag_and_drop_view,
                          ShelfButtonHost::DRAG_AND_DROP,
                          event);
 
   // Drag the item where it really belongs.
   Drag(location_in_screen_coordinates);
   return true;
 }
 
 bool ShelfView::Drag(const gfx::Point& location_in_screen_coordinates) {
-  if (!drag_and_drop_launcher_id_ ||
+  if (!drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   gfx::Point pt = location_in_screen_coordinates;
   views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_launcher_id_));
+      model_->ItemIndexByID(drag_and_drop_shelf_id_));
   ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root = location_in_screen_coordinates;
   ash::wm::ConvertPointFromScreen(
       ash::wm::GetRootWindowAt(location_in_screen_coordinates),
       &point_in_root);
   ui::MouseEvent event(ui::ET_MOUSE_DRAGGED, pt, point_in_root, 0, 0);
   PointerDraggedOnButton(drag_and_drop_view,
                          ShelfButtonHost::DRAG_AND_DROP,
                          event);
   return true;
 }
 
 void ShelfView::EndDrag(bool cancel) {
-  if (!drag_and_drop_launcher_id_)
+  if (!drag_and_drop_shelf_id_)
     return;
 
   views::View* drag_and_drop_view = view_model_->view_at(
-      model_->ItemIndexByID(drag_and_drop_launcher_id_));
+      model_->ItemIndexByID(drag_and_drop_shelf_id_));
   PointerReleasedOnButton(
       drag_and_drop_view, ShelfButtonHost::DRAG_AND_DROP, cancel);
 
   // Either destroy the temporarily created item - or - make the item visible.
   if (drag_and_drop_item_pinned_ && cancel)
     delegate_->UnpinAppWithID(drag_and_drop_app_id_);
   else if (drag_and_drop_view) {
     if (cancel) {
       // When a hosted drag gets canceled, the item can remain in the same slot
       // and it might have moved within the bounds. In that case the item need
       // to animate back to its correct location.
       AnimateToIdealBounds();
     } else {
       drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
     }
   }
 
-  drag_and_drop_launcher_id_ = 0;
+  drag_and_drop_shelf_id_ = 0;
 }
 
 void ShelfView::LayoutToIdealBounds() {
   if (bounds_animator_->IsAnimating()) {
     AnimateToIdealBounds();
     return;
   }
 
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
@@ skipping 220 matching lines @@
     // Now that the item animation starts, we have to make sure that the
     // padding of the first gets properly transferred to the new first item.
     if (i && view->border())
       view->SetBorder(views::Border::NullBorder());
     else if (!i && !view->border())
       UpdateFirstButtonPadding();
   }
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
-views::View* ShelfView::CreateViewForItem(const LauncherItem& item) {
+views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
   views::View* view = NULL;
   switch (item.type) {
     case TYPE_BROWSER_SHORTCUT:
     case TYPE_APP_SHORTCUT:
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
     case TYPE_DIALOG:
     case TYPE_APP_PANEL: {
       ShelfButton* button = ShelfButton::Create(this, this, layout_manager_);
       button->SetImage(item.image);
@@ skipping 76 matching lines @@
 
   ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[current_index].id);
   if (!item_delegate->IsDraggable()) {
     CancelDrag(-1);
     return;
   }
 
   // If this is not a drag and drop host operation and not the app list item,
   // check if the item got ripped off the shelf - if it did we are done.
-  if (!drag_and_drop_launcher_id_ && ash::switches::UseDragOffShelf() &&
+  if (!drag_and_drop_shelf_id_ && ash::switches::UseDragOffShelf() &&
       RemovableByRipOff(current_index) != NOT_REMOVABLE) {
     if (HandleRipOffDrag(event))
       return;
     // The rip off handler could have changed the location of the item.
     current_index = view_model_->GetIndexOfView(drag_view_);
   }
 
   // TODO: I don't think this works correctly with RTL.
   gfx::Point drag_point(event.location());
   ConvertPointToTarget(drag_view_, this, &drag_point);
@@ skipping 43 matching lines @@
   // 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);
+      delegate_->GetAppIDForShelfID(model_->items()[current_index].id);
 
   gfx::Point screen_location = event.root_location();
   ash::wm::ConvertPointToScreen(GetWidget()->GetNativeWindow()->GetRootWindow(),
                                 &screen_location);
 
   // To avoid ugly forwards and backwards flipping we use different constants
   // for ripping off / re-inserting the items.
   if (dragged_off_shelf_) {
     // If the shelf/overflow bubble bounds contains |screen_location| we insert
     // the item back into the shelf.
@@ skipping 104 matching lines @@
       drag_view_->layer()->SetOpacity(1.0f);
     } else if (RemovableByRipOff(current_index) != REMOVABLE) {
       // Make sure we do not try to remove un-removable items like items which
       // were not pinned or have to be always there.
       cancel = true;
       snap_back = true;
     } else {
       // Make sure the item stays invisible upon removal.
       drag_view_->SetVisible(false);
       std::string app_id =
-          delegate_->GetAppIDForLauncherID(model_->items()[current_index].id);
+          delegate_->GetAppIDForShelfID(model_->items()[current_index].id);
       delegate_->UnpinAppWithID(app_id);
     }
   }
   if (cancel || snap_back) {
     if (dragged_off_from_overflow_to_shelf_) {
       dragged_off_from_overflow_to_shelf_ = false;
       // Main shelf handles revert of dragged item.
       main_shelf_->EndDrag(true);
       drag_view_->layer()->SetOpacity(1.0f);
     } else if (!cancelling_drag_model_changed_) {
@@ skipping 19 matching lines @@
   }
   DestroyDragIconProxy();
 }
 
 ShelfView::RemovableState ShelfView::RemovableByRipOff(int index) {
   DCHECK(index >= 0 && index < model_->item_count());
   ShelfItemType type = model_->items()[index].type;
   if (type == TYPE_APP_LIST || type == TYPE_DIALOG || !delegate_->CanPin())
     return NOT_REMOVABLE;
 
-  std::string app_id =
-      delegate_->GetAppIDForLauncherID(model_->items()[index].id);
+  std::string app_id = delegate_->GetAppIDForShelfID(model_->items()[index].id);
   // Note: Only pinned app shortcuts can be removed!
   return (type == TYPE_APP_SHORTCUT && delegate_->IsAppPinned(app_id)) ?
       REMOVABLE : DRAGGABLE;
 }
 
 bool ShelfView::SameDragType(ShelfItemType typea, ShelfItemType typeb) const {
   switch (typea) {
     case TYPE_APP_SHORTCUT:
     case TYPE_BROWSER_SHORTCUT:
       return (typeb == TYPE_APP_SHORTCUT || typeb == TYPE_BROWSER_SHORTCUT);
@@ skipping 294 matching lines @@
   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 ShelfView::ShelfItemRemoved(int model_index, LauncherID id) {
+void ShelfView::ShelfItemRemoved(int model_index, ShelfID id) {
   if (id == context_menu_id_)
     launcher_menu_runner_.reset();
   {
     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);
 
@@ skipping 19 matching lines @@
     // item is ripped out from the shelf, its |view| is already invisible.
     AnimateToIdealBounds();
   }
 
   // Close the tooltip because it isn't needed any longer and its anchor view
   // will be deleted soon.
   if (tooltip_->GetCurrentAnchorView() == view)
     tooltip_->Close();
 }
 
-void ShelfView::ShelfItemChanged(int model_index,
-                                 const LauncherItem& old_item) {
-  const LauncherItem& item(model_->items()[model_index]);
+void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
+  const ShelfItem& item(model_->items()[model_index]);
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     model_index = CancelDrag(model_index);
     scoped_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     // Removing and re-inserting a view in our view model will strip the ideal
     // bounds from the item. To avoid recalculation of everything the bounds
     // get remembered and restored after the insertion to the previous value.
     gfx::Rect old_ideal_bounds = view_model_->ideal_bounds(model_index);
     view_model_->Remove(model_index);
@@ skipping 196 matching lines @@
         break;
     }
 
     ShelfItemDelegate* item_delegate =
         item_manager_->GetShelfItemDelegate(model_->items()[view_index].id);
     if (!item_delegate->ItemSelected(event))
       ShowListMenuForView(model_->items()[view_index], sender, event);
   }
 }
 
-bool ShelfView::ShowListMenuForView(const LauncherItem& item,
+bool ShelfView::ShowListMenuForView(const ShelfItem& item,
                                     views::View* source,
                                     const ui::Event& event) {
   scoped_ptr<ShelfMenuModel> menu_model;
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(item.id);
   menu_model.reset(item_delegate->CreateApplicationMenu(event.flags()));
 
   // Make sure we have a menu and it has at least two items in addition to the
   // application title and the 3 spacing separators.
   if (!menu_model.get() || menu_model->GetItemCount() <= 5)
@@ skipping 18 matching lines @@
   }
 
   scoped_ptr<ui::MenuModel> menu_model;
   ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
       model_->items()[view_index].id);
   menu_model.reset(item_delegate->CreateContextMenu(
       source->GetWidget()->GetNativeView()->GetRootWindow()));
   if (!menu_model)
     return;
 
-  base::AutoReset<LauncherID> reseter(
+  base::AutoReset<ShelfID> reseter(
       &context_menu_id_,
       view_index == -1 ? 0 : model_->items()[view_index].id);
 
   ShowMenu(scoped_ptr<views::MenuModelAdapter>(
                new views::MenuModelAdapter(menu_model.get())),
            source,
            point,
            true,
            source_type);
 }
@@ skipping 118 matching lines @@
     return true;
 
   base::TimeDelta delta =
       base::TimeDelta(event.time_stamp() - closing_event_time_);
   closing_event_time_ = base::TimeDelta();
   // TODO(skuhne): This time seems excessive, but it appears that the reposting
   // takes that long.  Need to come up with a better way of doing this.
   return (delta.InMilliseconds() < 0 || delta.InMilliseconds() > 130);
 }
 
-const LauncherItem* ShelfView::LauncherItemForView(
-    const views::View* view) const {
+const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
   int view_index = view_model_->GetIndexOfView(view);
   if (view_index == -1)
     return NULL;
   return &(model_->items()[view_index]);
 }
 
 bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
   if (view == GetAppListButtonView() &&
       Shell::GetInstance()->GetAppListWindow())
     return false;
-  const LauncherItem* item = LauncherItemForView(view);
+  const ShelfItem* item = ShelfItemForView(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::ForShelf(
       GetWidget()->GetNativeView())->shelf();
@@ skipping 12 matching lines @@
       break;
     case SHELF_ALIGNMENT_TOP:
       distance = coordinate.y() - bounds.bottom();
       break;
   }
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace internal
 }  // namespace ash