Drag and drop between app list and launcher - First patch

ui/app_list/views/apps_grid_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 "ui/app_list/views/apps_grid_view.h"
 
 #include <algorithm>
 
+#include "ui/app_list/app_list_item_model.h"
 #include "ui/app_list/apps_grid_view_delegate.h"
 #include "ui/app_list/pagination_model.h"
+#include "ui/app_list/views/app_list_dnd_host.h"
 #include "ui/app_list/views/app_list_item_view.h"
 #include "ui/app_list/views/page_switcher.h"
 #include "ui/app_list/views/pulsing_block_view.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/events/event.h"
 #include "ui/views/border.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_AURA)
@@ skipping 80 matching lines @@
                            PaginationModel* pagination_model)
     : model_(NULL),
       delegate_(delegate),
       pagination_model_(pagination_model),
       page_switcher_view_(new PageSwitcher(pagination_model)),
       cols_(0),
       rows_per_page_(0),
       selected_view_(NULL),
       drag_view_(NULL),
       drag_pointer_(NONE),
+      dnd_host_(NULL),
+      dnd_host_dispatched_drag_(false),
       page_flip_target_(-1),
       page_flip_delay_in_ms_(kPageFlipDelayInMs),
       ALLOW_THIS_IN_INITIALIZER_LIST(bounds_animator_(this)) {
   pagination_model_->AddObserver(this);
   AddChildView(page_switcher_view_);
 }
 
 AppsGridView::~AppsGridView() {
   if (model_) {
     model_->RemoveObserver(this);
@@ skipping 49 matching lines @@
 
 void AppsGridView::EnsureViewVisible(const views::View* view) {
   if (pagination_model_->has_transition())
     return;
 
   Index index = GetIndexOfView(view);
   if (IsValidIndex(index))
     pagination_model_->SelectPage(index.page, false);
 }
 
-void AppsGridView::InitiateDrag(views::View* view,
+void AppsGridView::InitiateDrag(AppListItemView* view,
                                 Pointer pointer,
                                 const ui::LocatedEvent& event) {
   if (drag_view_ || pulsing_blocks_model_.view_size())
     return;
 
   drag_view_ = view;
   drag_start_ = event.location();
 }
 
-void AppsGridView::UpdateDrag(views::View* view,
+void AppsGridView::UpdateDrag(AppListItemView* view,
                               Pointer pointer,
                               const ui::LocatedEvent& event) {
   if (!dragging() && drag_view_ &&
       ExceededDragThreshold(event.location() - drag_start_)) {
     drag_pointer_ = pointer;
     // Move the view to the front so that it appears on top of other views.
     ReorderChildView(drag_view_, -1);
     bounds_animator_.StopAnimatingView(drag_view_);
   }
   if (drag_pointer_ != pointer)
     return;
 
+  // If a dnd host is provided, see if the drag operation needs to be forwarded.
+  DispatchDragEventToDnDHost(event);
   ExtractDragLocation(event, &last_drag_point_);
 
   const Index last_drop_target = drop_target_;
   CalculateDropTarget(last_drag_point_, false);
   MaybeStartPageFlipTimer(last_drag_point_);
 
   gfx::Point page_switcher_point(last_drag_point_);
   views::View::ConvertPointToTarget(this, page_switcher_view_,
                                     &page_switcher_point);
   page_switcher_view_->UpdateUIForDragPoint(page_switcher_point);
 
   if (last_drop_target != drop_target_)
     AnimateToIdealBounds();
   drag_view_->SetPosition(
       gfx::PointAtOffsetFromOrigin(last_drag_point_ - drag_start_));
 }
 
 void AppsGridView::EndDrag(bool cancel) {
-  if (!cancel && dragging() && drag_view_) {
+  if (dnd_host_dispatched_drag_) {
+    dnd_host_dispatched_drag_ = false;
+    dnd_host_->EndDrag(cancel);
+  } else if (!cancel && dragging() && drag_view_) {
     CalculateDropTarget(last_drag_point_, true);
     if (IsValidIndex(drop_target_))
       MoveItemInModel(drag_view_, drop_target_);
   }
 
   drag_pointer_ = NONE;
   drop_target_ = Index();
   if (drag_view_) {
     drag_view_ = NULL;
     AnimateToIdealBounds();
   }
 
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
 bool AppsGridView::IsDraggedView(const views::View* view) const {
   return drag_view_ == view;
 }
 
+void AppsGridView::SetAppListDnDHost(ApplicationDnDHost* dnd_host) {
+  dnd_host_ = dnd_host;
+}
+
 void AppsGridView::Prerender(int page_index) {
   Layout();
   int start = std::max(0, (page_index - kPrerenderPages) * tiles_per_page());
   int end = std::min(view_model_.view_size(),
                      (page_index + 1 + kPrerenderPages) * tiles_per_page());
   for (int i = start; i < end; i++) {
     AppListItemView* v = static_cast<AppListItemView*>(view_model_.view_at(i));
     v->Prerender();
   }
 }
@@ skipping 400 matching lines @@
   }
 
   // Limits to the last possible slot on last page.
   if (drop_target_.page == pagination_model_->total_pages() - 1) {
     drop_target_.slot = std::min(
         (view_model_.view_size() - 1) % tiles_per_page(),
         drop_target_.slot);
   }
 }
 
+void AppsGridView::DispatchDragEventToDnDHost(const ui::LocatedEvent& event) {
+  if (!drag_view_ || !dnd_host_)
+    return;
+  if (bounds().Contains(last_drag_point_)) {
+    // The event was issued inside the app menu and we should get all events.
+    if (dnd_host_dispatched_drag_) {
+      // The DnD host was previously called and needs to be informed that the
+      // session returns to the owner.
+      dnd_host_dispatched_drag_ = false;
+      dnd_host_->EndDrag(true);
+    }
+  } else {
+    // The event happened outside our app menu and we might need to dispatch.
+    if (dnd_host_dispatched_drag_) {
+      // Dispatch since we have already started.
+      if (!dnd_host_->Drag(event.root_location())) {
+        // The host is not active any longer and we cancel the operation.
+        dnd_host_dispatched_drag_ = false;
+        dnd_host_->EndDrag(true);
+      }
+    } else {
+      if (dnd_host_->StartDrag(drag_view_->model()->app_id(),
+                               event.root_location())) {
+        // From now on we forward the drag events.
+        dnd_host_dispatched_drag_ = true;
+        // Any flip operations are stopped.
+        page_flip_timer_.Stop();
+        page_flip_target_ = -1;
+      }
+    }
+  }
+}
+
 void AppsGridView::MaybeStartPageFlipTimer(const gfx::Point& drag_point) {
   int new_page_flip_target = -1;
 
   if (page_switcher_view_->bounds().Contains(drag_point)) {
     gfx::Point page_switcher_point(drag_point);
     views::View::ConvertPointToTarget(this, page_switcher_view_,
                                       &page_switcher_point);
     new_page_flip_target =
         page_switcher_view_->GetPageForPoint(page_switcher_point);
   }
@@ skipping 127 matching lines @@
     Layout();
 }
 
 void AppsGridView::OnAppListModelStatusChanged() {
   UpdatePulsingBlockViews();
   Layout();
   SchedulePaint();
 }
 
 }  // namespace app_list