Adding drag-drop support in and out of the Browser Action overflow menu....

chrome/browser/views/browser_actions_container.cc

 // Copyright (c) 2010 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 "chrome/browser/views/browser_actions_container.h"
 
 #include "app/gfx/canvas.h"
 #include "app/resource_bundle.h"
 #include "app/slide_animation.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/extension_tabs_module.h"
 #include "chrome/browser/renderer_host/render_widget_host_view.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/view_ids.h"
 #include "chrome/browser/views/detachable_toolbar_view.h"
 #include "chrome/browser/views/extensions/browser_action_drag_data.h"
-#include "chrome/browser/views/extensions/browser_action_overflow_menu_controller.h"
 #include "chrome/browser/views/extensions/extension_popup.h"
 #include "chrome/browser/views/toolbar_view.h"
 #include "chrome/common/notification_source.h"
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 #include "grit/app_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "views/controls/button/menu_button.h"
@@ skipping 260 matching lines @@
 
 BrowserActionsContainer::BrowserActionsContainer(
     Profile* profile, ToolbarView* toolbar)
     : profile_(profile),
       toolbar_(toolbar),
       popup_(NULL),
       popup_button_(NULL),
       model_(NULL),
       resize_gripper_(NULL),
       chevron_(NULL),
+      overflow_menu_(NULL),
       suppress_chevron_(false),
       resize_amount_(0),
       animation_target_size_(0),
       drop_indicator_position_(-1),
-      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(task_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(show_menu_task_factory_(this)) {
   SetID(VIEW_ID_BROWSER_ACTION_TOOLBAR);
 
   ExtensionsService* extension_service = profile->GetExtensionsService();
   if (!extension_service)  // The |extension_service| can be NULL in Incognito.
     return;
 
   registrar_.Add(this, NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE,
                  Source<Profile>(profile_));
 
   model_ = extension_service->toolbar_model();
@@ skipping 21 matching lines @@
     // except when no width has been saved. So, in that case ask the model
     // how many icons we'll show and set initial size to that.
     predefined_width = IconCountToWidth(model_->size());
   }
   container_size_ = gfx::Size(predefined_width, kButtonSize);
 }
 
 BrowserActionsContainer::~BrowserActionsContainer() {
   if (model_)
     model_->RemoveObserver(this);
+  StopShowFolderDropMenuTimer();
   CloseOverflowMenu();
   HidePopup();
   DeleteBrowserActionViews();
 }
 
 // Static.
 void BrowserActionsContainer::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterIntegerPref(prefs::kBrowserActionContainerWidth, 0);
 }
 
@@ skipping 17 matching lines @@
   return NULL;
 }
 
 void BrowserActionsContainer::RefreshBrowserActionViews() {
   for (size_t i = 0; i < browser_action_views_.size(); ++i)
     browser_action_views_[i]->button()->UpdateState();
 }
 
 void BrowserActionsContainer::CloseOverflowMenu() {
   // Close the overflow menu if open (and the context menu off of that).
-  if (overflow_menu_.get())
+  if (overflow_menu_)
     overflow_menu_->CancelMenu();
 }
 
+void BrowserActionsContainer::StopShowFolderDropMenuTimer() {
+  show_menu_task_factory_.RevokeAll();
+}
+
+void BrowserActionsContainer::StartShowFolderDropMenuTimer() {
+  int delay = View::GetMenuShowDelay();
+  MessageLoop::current()->PostDelayedTask(FROM_HERE,
+      show_menu_task_factory_.NewRunnableMethod(
+          &BrowserActionsContainer::ShowDropFolder),
+      delay);
+}
+
+void BrowserActionsContainer::ShowDropFolder() {
+  DCHECK(!overflow_menu_);
+  overflow_menu_ = new BrowserActionOverflowMenuController(
+      this, chevron_, browser_action_views_, VisibleBrowserActions());
+  overflow_menu_->set_observer(this);
+  overflow_menu_->RunMenu(GetWindow()->GetNativeWindow(), true);
+}
+
+void BrowserActionsContainer::SetDropIndicator(int x_pos) {
+  if (drop_indicator_position_ != x_pos) {
+    drop_indicator_position_ = x_pos;
+    SchedulePaint();
+  }
+}
+
 void BrowserActionsContainer::CreateBrowserActionViews() {
   DCHECK(browser_action_views_.empty());
   for (ExtensionList::iterator iter = model_->begin();
        iter != model_->end(); ++iter) {
     BrowserActionView* view = new BrowserActionView(*iter, this);
     browser_action_views_.push_back(view);
     AddChildView(view);
   }
 }
 
@@ skipping 227 matching lines @@
     return false;
   return drop_data.IsFromProfile(profile_);
 }
 
 void BrowserActionsContainer::OnDragEntered(
     const views::DropTargetEvent& event) {
 }
 
 int BrowserActionsContainer::OnDragUpdated(
     const views::DropTargetEvent& event) {
+  // First check if we are above the chevron (overflow) menu.
+  if (GetViewForPoint(event.location()) == chevron_) {
+    SetDropIndicator(-1);
+
+    if (show_menu_task_factory_.empty() && !overflow_menu_)
+      StartShowFolderDropMenuTimer();
+    return DragDropTypes::DRAG_MOVE;
+  } else {
+    StopShowFolderDropMenuTimer();
+  }
+
   // Modifying the x value before clamping affects how far you have to drag to
   // get the drop indicator to shift to another position. Modifying after
   // clamping affects where the drop indicator is drawn.
 
   // We add half a button size so that when you drag a button to the right and
   // you are half-way dragging across a button the drop indicator moves from the
   // left of that button to the right of that button.
   int x = event.x() + (kButtonSize / 2) + (2 * kBrowserActionButtonPadding);
   if (chevron_->IsVisible())
     x += chevron_->bounds().width();
   x = ClampToNearestIconCount(x, false);
 
   if (!UILayoutIsRightToLeft() && chevron_->IsVisible()) {
     // The clamping function includes the chevron width. In LTR locales, the
     // chevron is on the right and we never want to account for its width. In
     // RTL it is on the left and we always want to count the width.
     x -= chevron_->width();
   }
 
   // Clamping gives us a value where the next button will be drawn, but we want
   // to subtract the padding (and then some) to make it appear in-between the
   // buttons.
-  drop_indicator_position_ = x - kBrowserActionButtonPadding -
+  SetDropIndicator(x - kBrowserActionButtonPadding -
       (UILayoutIsRightToLeft() ? kDropIndicatorOffsetRtl :
-                                 kDropIndicatorOffsetLtr);
-
-  SchedulePaint();
+                                 kDropIndicatorOffsetLtr));
   return DragDropTypes::DRAG_MOVE;
 }
 
 void BrowserActionsContainer::OnDragExited() {
+  StopShowFolderDropMenuTimer();
   drop_indicator_position_ = -1;
   SchedulePaint();
 }
 
 int BrowserActionsContainer::OnPerformDrop(
     const views::DropTargetEvent& event) {
   BrowserActionDragData data;
   if (!data.Read(event.GetData()))
     return DragDropTypes::DRAG_NONE;
 
@@ skipping 25 matching lines @@
   // * Well, it can also point to the end, but not when dragging to the left. :)
   if (i > data.index())
     --i;
 
   model_->MoveBrowserAction(dragging, i);
 
   OnDragExited();  // Perform clean up after dragging.
   return DragDropTypes::DRAG_MOVE;
 }
 
+void BrowserActionsContainer::MoveBrowserAction(
+    const std::string& extension_id, size_t new_index) {
+  ExtensionsService* service = profile_->GetExtensionsService();
+  Extension* extension = service->GetExtensionById(extension_id, false);
+  model_->MoveBrowserAction(extension, new_index);
+  SchedulePaint();
+}
+
 void BrowserActionsContainer::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_HOST_VIEW_SHOULD_CLOSE:
       // If we aren't the host of the popup, then disregard the notification.
       if (!popup_ || Details<ExtensionHost>(popup_->host()) != details)
         return;
 
       HidePopup();
@@ skipping 41 matching lines @@
   // This is a bit annoying.  If you click on the button that generated the
   // current popup, then we first get this lost focus message, and then
   // we get the click action.  This results in the popup being immediately
   // shown again.  To workaround this, we put in a delay.
   MessageLoop::current()->PostTask(FROM_HERE,
       task_factory_.NewRunnableMethod(&BrowserActionsContainer::HidePopup));
 }
 
 void BrowserActionsContainer::RunMenu(View* source, const gfx::Point& pt) {
   if (source == chevron_) {
-    overflow_menu_.reset(new BrowserActionOverflowMenuController(
-        this, chevron_, browser_action_views_, VisibleBrowserActions()));
-    overflow_menu_->RunMenu(GetWindow()->GetNativeWindow());
+    overflow_menu_ = new BrowserActionOverflowMenuController(
+        this, chevron_, browser_action_views_, VisibleBrowserActions());
+    overflow_menu_->set_observer(this);
+    overflow_menu_->RunMenu(GetWindow()->GetNativeWindow(), false);
   }
 }
 
 void BrowserActionsContainer::WriteDragData(
     View* sender, int press_x, int press_y, OSExchangeData* data) {
   DCHECK(data);
 
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
     if (browser_action_views_[i]->button() == sender) {
       BrowserActionDragData drag_data(
@@ skipping 212 matching lines @@
 void BrowserActionsContainer::AnimationEnded(const Animation* animation) {
   container_size_.set_width(animation_target_size_);
   animation_target_size_ = 0;
   resize_amount_ = 0;
   OnBrowserActionVisibilityChanged();
   suppress_chevron_ = false;
 
   profile_->GetPrefs()->SetInteger(prefs::kBrowserActionContainerWidth,
                                    container_size_.width());
 }
+
+void BrowserActionsContainer::NotifyMenuDeleted(
+    BrowserActionOverflowMenuController* controller) {
+  DCHECK(controller == overflow_menu_);
+  overflow_menu_ = NULL;
+}