[Win] App launcher drag/drop.

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 "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/win/shortcut.h"

[xiyuan, 2013/06/19 05:41:38]

Would this need to be wrapped in a #if defined(OS_WIN)?

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

 #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_drag_and_drop_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/dragdrop/drag_utils.h"
+#include "ui/base/dragdrop/drop_target_win.h"

[xiyuan, 2013/06/19 05:41:38]

and this?

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

+#include "ui/base/dragdrop/os_exchange_data.h"
+#include "ui/base/dragdrop/os_exchange_data_provider_win.h"

[xiyuan, 2013/06/19 05:41:38]

and this?

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

 #include "ui/base/events/event.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/border.h"
 #include "ui/views/view_model_utils.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_AURA)
 #include "ui/aura/root_window.h"
 #endif
 
@@ skipping 72 matching lines @@
   const gfx::Rect layer_start_;
   const gfx::Rect layer_target_;
 
   DISALLOW_COPY_AND_ASSIGN(RowMoveAnimationDelegate);
 };
 
 }  // namespace
 
 namespace app_list {
 
+#if defined(OS_WIN)
+// Interprets drag events sent from Windows via the drag/drop API and forwards
+// them to AppsGridView.
+// On Windows, in order to have the OS perform the drag properly we need to
+// provide it with a shortcut file which may or may not exist at the time the
+// drag is started. Therefore while waiting for that shortcut to be located we
+// just do a regular "internal" drag and transition into the synchronous drag
+// when the shortcut is found/created. Hence a synchronous drag is an optional
+// phase of a regular drag and non-Windows platforms drags are equivalent to a
+// Windows drag that never enters the synchronous drag phase.
+class SynchronousDrag : public ui::DragSourceWin {
+ public:
+  SynchronousDrag(app_list::AppsGridView* grid_view,
+              app_list::AppListItemView* drag_view,
+              const gfx::Point& drag_view_offset)
+      : grid_view_(grid_view),
+        drag_view_(drag_view),
+        drag_view_offset_(drag_view_offset),
+        has_shortcut_path_(false),
+        running_(false),
+        canceled_(false) {
+  }
+
+  void set_shortcut_path(const base::FilePath& shortcut_path) {
+    has_shortcut_path_ = true;
+    shortcut_path_ = shortcut_path;
+  }
+
+  bool CanRun() {
+    return has_shortcut_path_ && !running_;
+  }
+
+  void Run() {
+    DCHECK(CanRun());
+    running_ = true;
+
+    ui::OSExchangeData data;
+    SetupExchangeData(&data);
+
+    // Hide the dragged view because the OS is going to create its own.
+    gfx::Size drag_view_size = drag_view_->size();

[xiyuan, 2013/06/19 05:41:38]

nit: const gfx::Size

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

+    drag_view_->SetSize(gfx::Size(0, 0));
+
+    // Blocks until the drag is finished. Calls into the ui::DragSourceWin
+    // methods.
+    DWORD effects;
+    DoDragDrop(ui::OSExchangeDataProviderWin::GetIDataObject(data),
+               this, DROPEFFECT_MOVE | DROPEFFECT_LINK, &effects);
+
+    // Restore the dragged view to its original size.
+    drag_view_->SetSize(drag_view_size);
+
+    grid_view_->EndDrag(canceled_ || !IsCursorWithinGridView());
+  }
+
+ private:
+  // Overridden from ui::DragSourceWin.
+  virtual void OnDragSourceCancel() OVERRIDE {
+    canceled_ = true;
+  }
+
+  virtual void OnDragSourceDrop() OVERRIDE {
+  }
+
+  virtual void OnDragSourceMove() OVERRIDE {
+    grid_view_->UpdateDrag(app_list::AppsGridView::MOUSE,
+                           GetCursorInGridViewCoords());
+
+    // Don't turn pages if the cursor is dragged outside the view.
+    if (!IsCursorWithinGridView())
+      grid_view_->StopPageFlipTimer();
+

[xiyuan, 2013/06/19 05:41:38]

nit: nuke empty line

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

+  }
+
+  void SetupExchangeData(ui::OSExchangeData* data) {
+    data->SetFilename(shortcut_path_);
+    gfx::ImageSkia image(drag_view_->GetDragImage());
+    gfx::Size image_size(image.size());
+    drag_utils::SetDragImageOnDataObject(
+        image,
+        image.size(),
+        gfx::Vector2d(drag_view_offset_.x(), drag_view_offset_.y()),
+        data);
+  }
+
+  HWND GetGridViewHWND() {
+    return grid_view_->GetWidget()->GetTopLevelWidget()->GetNativeView();
+  }
+
+  bool IsCursorWithinGridView() {
+    POINT p;
+    GetCursorPos(&p);
+    return GetGridViewHWND() == WindowFromPoint(p);
+  }
+
+  gfx::Point GetCursorInGridViewCoords() {
+    POINT p;
+    GetCursorPos(&p);
+    ScreenToClient(GetGridViewHWND(), &p);
+    gfx::Point grid_view_pt(p.x, p.y);
+    views::View::ConvertPointFromWidget(grid_view_, &grid_view_pt);
+    return grid_view_pt;
+  }
+
+  app_list::AppsGridView* grid_view_;
+  app_list::AppListItemView* drag_view_;
+  gfx::Point drag_view_offset_;
+  bool has_shortcut_path_;
+  base::FilePath shortcut_path_;
+  bool running_;
+  bool canceled_;

[xiyuan, 2013/06/19 05:41:38]

nit: DISALLOW_COPY_AND_ASSIGN?

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

+};
+#endif // defined(OS_WIN)
+
+

[xiyuan, 2013/06/19 05:41:38]

nit: nuke empty line

[koz (OOO until 15th September), 2013/06/19 07:55:08]

Done.

 AppsGridView::AppsGridView(AppsGridViewDelegate* delegate,
                            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),
@@ skipping 91 matching lines @@
     delta.set_y(delta.y() + drag_view_->title()->size().height() / 2);
     // We have to hide the original item since the drag and drop host will do
     // the OS dependent code to "lift off the dragged item".
     drag_and_drop_host_->CreateDragIconProxy(event.root_location(),
                                              view->model()->icon(),
                                              drag_view_,
                                              delta,
                                              kDragAndDropProxyScale);
     HideView(drag_view_, true);
   }
-  drag_start_ = event.location();
+  drag_view_offset_ = event.location();
+  ExtractDragLocation(event, &drag_start_grid_view_);
+  drag_view_start_ = gfx::Point(drag_view_->x(), drag_view_->y());
 }
 
-void AppsGridView::UpdateDrag(AppListItemView* view,
-                              Pointer pointer,
-                              const ui::LocatedEvent& event) {
+void AppsGridView::OnGotShortcutPath(const base::FilePath& path) {
+#if defined(OS_WIN)
+  // Drag may have ended before we get the shortcut path.
+  if (!synchronous_drag_)
+    return;
+  // Setting the shortcut path here means the next time we hit UpdateDrag()
+  // we'll enter the synchronous drag.
+  // NOTE we don't Run() the drag here because that causes animations not to
+  // update for some reason.
+  synchronous_drag_->set_shortcut_path(path);
+  DCHECK(synchronous_drag_->CanRun());
+#endif
+}
+
+void AppsGridView::StartSettingUpSynchronousDrag() {
+#if defined(OS_WIN)
+  delegate_->GetShortcutPathForApp(
+    drag_view_->model()->app_id(),
+    base::Bind(&AppsGridView::OnGotShortcutPath, base::Unretained(this)));
+  synchronous_drag_ = new SynchronousDrag(this, drag_view_, drag_view_offset_);
+#endif
+}
+
+bool AppsGridView::RunSynchronousDrag() {
+#if defined(OS_WIN)
+  if (synchronous_drag_ && synchronous_drag_->CanRun()) {
+    synchronous_drag_->Run();
+    synchronous_drag_ = NULL;
+    return true;
+  }
+#endif
+  return false;
+}
+
+void AppsGridView::CleanUpSynchronousDrag() {
+#if defined(OS_WIN)
+  synchronous_drag_ = NULL;
+#endif
+}
+
+void AppsGridView::UpdateDragFromItem(Pointer pointer,
+                                      const ui::LocatedEvent& event) {
+  gfx::Point drag_point_in_grid_view;
+  ExtractDragLocation(event, &drag_point_in_grid_view);
+  UpdateDrag(pointer, drag_point_in_grid_view);
+}
+
+void AppsGridView::UpdateDrag(Pointer pointer, const gfx::Point& point) {
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
-  if (!dragging() && ExceededDragThreshold(event.location() - drag_start_)) {
+  if (RunSynchronousDrag())
+    return;
+
+  gfx::Vector2d drag_vector(point - drag_start_grid_view_);
+  if (!dragging() && ExceededDragThreshold(drag_vector)) {
     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_);
+
+    StartSettingUpSynchronousDrag();
   }
   if (drag_pointer_ != pointer)
     return;
 
-  ExtractDragLocation(event, &last_drag_point_);
+  last_drag_point_ = point;
   const Index last_drop_target = drop_target_;
   CalculateDropTarget(last_drag_point_, false);
 
   // If a drag and drop host is provided, see if the drag operation needs to be
   // forwarded.
-  DispatchDragEventToDragAndDropHost(event);
+  DispatchDragEventToDragAndDropHost(last_drag_point_);
 
   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();
 
   if (drag_and_drop_host_)
-    drag_and_drop_host_->UpdateDragIconProxy(event.root_location());
+    drag_and_drop_host_->UpdateDragIconProxy(point);

[xiyuan, 2013/06/19 05:41:38]

This probably breaks cros because event.root_location() is in RootWindow's
coordinates. It is complicated to convert from a view's coordinates back. Either
convert view's coordinates to screen coordinates then using ScreenPositionClient
to convert it to a RootWindow or convert it to widget's coordinates then find
out which RootWindow the widget is on then convert it. It might easier just
passing down the root location or original LocatedEvent. 

[koz (OOO until 15th September), 2013/06/19 07:55:08]

I see, thanks for catching this. I've rearranged it to get the root location to
the drag_and_drop_host_. Is there a concise explanation for what a root_location
is and why it differs from platform to platform (am I right that on Windows it
is the coordinates in terms of the HWND?)

[xiyuan, 2013/06/19 16:21:38]

oshima has a ddoc for the coordinates used for ChromeOS and I think part of it
(HWC and RWC) probably applies to all aura builds (win aura and linux aura). For
non-aura Windows, think you are right that root_location would be the same as
location.

https://docs.google.com/a/google.com/document/d/1ZFVWOZLCQygYVMv05y6AJ25nUzM5...

[koz (OOO until 15th September), 2013/06/20 13:52:23]

Cool, thanks for the link!

 
-  drag_view_->SetPosition(
-      gfx::PointAtOffsetFromOrigin(last_drag_point_ - drag_start_));
+  drag_view_->SetPosition(drag_view_start_ + drag_vector);
 }
 
 void AppsGridView::EndDrag(bool cancel) {
   // EndDrag was called before if |drag_view_| is NULL.
   if (!drag_view_)
     return;
 
   if (forward_events_to_drag_and_drop_host_) {
     forward_events_to_drag_and_drop_host_ = false;
     drag_and_drop_host_->EndDrag(cancel);
   } else if (!cancel && dragging()) {
     CalculateDropTarget(last_drag_point_, true);
     if (IsValidIndex(drop_target_))
       MoveItemInModel(drag_view_, drop_target_);
   }
 
   if (drag_and_drop_host_) {
     // If we had a drag and drop proxy icon, we delete it and make the real
     // item visible again.
     drag_and_drop_host_->DestroyDragIconProxy();
     HideView(drag_view_, false);
   }
 
+  // The drag can be ended after the synchronous drag is created but before it
+  // is Run().
+  CleanUpSynchronousDrag();
+
   drag_pointer_ = NONE;
   drop_target_ = Index();
   drag_view_ = NULL;
   AnimateToIdealBounds();
 
+  StopPageFlipTimer();
+}
+
+void AppsGridView::StopPageFlipTimer() {
   page_flip_timer_.Stop();
   page_flip_target_ = -1;
 }
 
 bool AppsGridView::IsDraggedView(const views::View* view) const {
   return drag_view_ == view;
 }
 
 void AppsGridView::SetDragAndDropHostOfCurrentAppList(
     ApplicationDragAndDropHost* drag_and_drop_host) {
@@ skipping 16 matching lines @@
   const gfx::Size tile_size = gfx::Size(kPreferredTileWidth,
                                         kPreferredTileHeight);
   const int page_switcher_height =
       page_switcher_view_->GetPreferredSize().height();
   return gfx::Size(
       tile_size.width() * cols_ + insets.width(),
       tile_size.height() * rows_per_page_ +
           page_switcher_height + insets.height());
 }
 
+bool AppsGridView::GetDropFormats(
+    int* formats,
+    std::set<OSExchangeData::CustomFormat>* custom_formats) {
+  // TODO(koz): Only accept a specific drag type for app shortcuts.
+  *formats = OSExchangeData::FILE_NAME;
+  return true;
+}
+
+bool AppsGridView::CanDrop(const OSExchangeData& data) {
+  return true;

[xiyuan, 2013/06/19 05:41:38]

Should this be false since we don't support dropping on app list?

[koz (OOO until 15th September), 2013/06/19 07:55:08]

This being true puts the "moved" icon next to the cursor while we're dragging
app items around the app list, the same one you get when dragging blocks of text
around in a text editor.

It does mean that the app list will show that for any dragged object that has a
filename, which is why I've got a TODO for myself above. I think it's probably
hard to drag a file onto the app launcher anyway, so not too important to fix.

+}
+
+int AppsGridView::OnDragUpdated(const ui::DropTargetEvent& event) {
+  return ui::DragDropTypes::DRAG_MOVE;
+}
+
 void AppsGridView::Layout() {
   if (bounds_animator_.IsAnimating())
     bounds_animator_.Cancel();
 
   CalculateIdealBounds();
   for (int i = 0; i < view_model_.view_size(); ++i) {
     views::View* view = view_model_.view_at(i);
     if (view != drag_view_)
       view->SetBoundsRect(view_model_.ideal_bounds(i));
   }
@@ skipping 404 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::DispatchDragEventToDragAndDropHost(
-    const ui::LocatedEvent& event) {
+    const gfx::Point& point) {
   if (!drag_view_ || !drag_and_drop_host_)
     return;
   if (bounds().Contains(last_drag_point_)) {
     // The event was issued inside the app menu and we should get all events.
     if (forward_events_to_drag_and_drop_host_) {
       // The DnD host was previously called and needs to be informed that the
       // session returns to the owner.
       forward_events_to_drag_and_drop_host_ = false;
       drag_and_drop_host_->EndDrag(true);
     }
   } else {
     // The event happened outside our app menu and we might need to dispatch.
     if (forward_events_to_drag_and_drop_host_) {
       // Dispatch since we have already started.
-      if (!drag_and_drop_host_->Drag(event.root_location())) {
+      if (!drag_and_drop_host_->Drag(point)) {
         // The host is not active any longer and we cancel the operation.
         forward_events_to_drag_and_drop_host_ = false;
         drag_and_drop_host_->EndDrag(true);
       }
     } else {
       if (drag_and_drop_host_->StartDrag(drag_view_->model()->app_id(),
-                                         event.root_location())) {
+                                         point)) {
         // From now on we forward the drag events.
         forward_events_to_drag_and_drop_host_ = true;
         // Any flip operations are stopped.
-        page_flip_timer_.Stop();
-        page_flip_target_ = -1;
+        StopPageFlipTimer();
       }
     }
   }
 }
 
 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);
@@ skipping 140 matching lines @@
 
 void AppsGridView::HideView(views::View* view, bool hide) {
 #if defined(USE_AURA)
   ui::ScopedLayerAnimationSettings animator(view->layer()->GetAnimator());
   animator.SetPreemptionStrategy(ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
   view->layer()->SetOpacity(hide ? 0 : 1);
 #endif
 }
 
 }  // namespace app_list