Support reordering of Browser Actions within the container. Currently does no...

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"
 #include "views/controls/button/text_button.h"
 #include "views/window/window.h"
 
 #include "grit/theme_resources.h"
 
 // The size (both dimensions) of the buttons for page actions.
 static const int kButtonSize = 29;
 
 // The padding between the browser actions and the OmniBox/page menu.
 static const int kHorizontalPadding = 4;
+static const int kHorizontalPaddingRtl = 8;
 
 // The padding between browser action buttons. Visually, the actual number of
 // empty (non-drawing) pixels is this value + 2 when adjacent browser icons
 // use their maximum allowed size.
 static const int kBrowserActionButtonPadding = 3;
 
 // This is the same value from toolbar.cc. We position the browser actions
 // container flush with the edges of the toolbar as a special case so that we
 // can draw the badge outside the visual bounds of the container.
 static const int kControlVertOffset = 6;
 
 // The margin between the divider and the chrome menu buttons.
 static const int kDividerHorizontalMargin = 2;
 
 // The padding above and below the divider.
 static const int kDividerVerticalPadding = 9;
 
 // The margin above the chevron.
 static const int kChevronTopMargin = 9;
 
 // The margin to the right of the chevron.
 static const int kChevronRightMargin = 4;
 
 // Extra hit-area for the resize gripper.
 static const int kExtraResizeArea = 4;
 
+// Width of the drop indicator.
+static const int kDropIndicatorWidth = 2;
+
+// Color of the drop indicator.
+static const SkColor kDropIndicatorColor = SK_ColorBLACK;
+
+// The x offset for the drop indicator (how much we shift it by).
+static const int kDropIndicatorOffsetLtr = 3;
+static const int kDropIndicatorOffsetRtl = 9;
+
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionButton
 
 BrowserActionButton::BrowserActionButton(Extension* extension,
                                          BrowserActionsContainer* panel)
     : MenuButton(this, L"", NULL, false),
       browser_action_(extension->browser_action()),
       extension_(extension),
       tracker_(NULL),
       showing_context_menu_(false),
@@ skipping 172 matching lines @@
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserActionView
 
 BrowserActionView::BrowserActionView(Extension* extension,
                                      BrowserActionsContainer* panel)
     : panel_(panel) {
   button_ = new BrowserActionButton(extension, panel);
+  button_->SetDragController(panel_);
   AddChildView(button_);
   button_->UpdateState();
 }
 
 void BrowserActionView::Layout() {
   button_->SetBounds(0, kControlVertOffset, width(), kButtonSize);
 }
 
 void BrowserActionView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
@@ skipping 13 matching lines @@
     : profile_(profile),
       toolbar_(toolbar),
       popup_(NULL),
       popup_button_(NULL),
       model_(NULL),
       resize_gripper_(NULL),
       chevron_(NULL),
       suppress_chevron_(false),
       resize_amount_(0),
       animation_target_size_(0),
+      drop_indicator_position_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(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_));
 
@@ skipping 10 matching lines @@
   SkBitmap* chevron_image = rb.GetBitmapNamed(IDR_BOOKMARK_BAR_CHEVRONS);
   chevron_ = new views::MenuButton(NULL, std::wstring(), this, false);
   chevron_->SetVisible(false);
   chevron_->SetIcon(*chevron_image);
   // Chevron contains >> that should point left in LTR locales.
   chevron_->EnableCanvasFlippingForRTLUI(true);
   AddChildView(chevron_);
 
   int predefined_width =
       profile_->GetPrefs()->GetInteger(prefs::kBrowserActionContainerWidth);
+  if (predefined_width == 0) {
+    // The width will never be 0 (due to container min size restriction)
+    // 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);
   CloseOverflowMenu();
   HidePopup();
   DeleteBrowserActionViews();
 }
@@ skipping 27 matching lines @@
   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())
     overflow_menu_->CancelMenu();
 }
 
+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);
+  }
+}
+
 void BrowserActionsContainer::DeleteBrowserActionViews() {
   if (!browser_action_views_.empty()) {
     for (size_t i = 0; i < browser_action_views_.size(); ++i)
       RemoveChildView(browser_action_views_[i]);
     STLDeleteContainerPointers(browser_action_views_.begin(),
                                browser_action_views_.end());
     browser_action_views_.clear();
   }
 }
 
@@ skipping 85 matching lines @@
     return gfx::Size(0, 0);
 
   // We calculate the size of the view by taking the current width and
   // subtracting resize_amount_ (the latter represents how far the user is
   // resizing the view or, if animating the snapping, how far to animate it).
   // But we also clamp it to a minimum size and the maximum size, so that the
   // container can never shrink too far or take up more space than it needs. In
   // other words: ContainerMinSize() < width() - resize < ClampTo(MAX).
   int width = std::max(ContainerMinSize(),
                        container_size_.width() - resize_amount_);
-  int max_width = ClampToNearestIconCount(-1);  // -1 gives max width.
+  int max_width = ClampToNearestIconCount(-1, false);  // -1 gives max width.
   width = std::min(width, max_width);
 
   return gfx::Size(width, kButtonSize);
 }
 
 void BrowserActionsContainer::Layout() {
   if (!resize_gripper_ || !chevron_)
     return;  // These classes are not created in Incognito mode.
   if (browser_action_views_.size() == 0) {
     resize_gripper_->SetVisible(false);
     chevron_->SetVisible(false);
     return;
   }
 
   int x = 0;
   if (resize_gripper_->IsVisible()) {
     // We'll draw the resize gripper a little wider, to add some invisible hit
     // target area - but we don't account for it anywhere.
     gfx::Size sz = resize_gripper_->GetPreferredSize();
     resize_gripper_->SetBounds(x, (height() - sz.height()) / 2 + 1,
                                sz.width() + kExtraResizeArea, sz.height());
     x += sz.width();
   }
 
-  x += kHorizontalPadding;
+  x += UILayoutIsRightToLeft() ? kHorizontalPaddingRtl : kHorizontalPadding;
 
   // Calculate if all icons fit without showing the chevron. We need to know
   // this beforehand, because showing the chevron will decrease the space that
   // we have to draw the visible ones (ie. if one icon is visible and another
   // doesn't have enough room).
   int last_x_of_icons = x +
       (browser_action_views_.size() * kButtonSize) +
       ((browser_action_views_.size() - 1) *
           kBrowserActionButtonPadding);
 
@@ skipping 30 matching lines @@
 
 void BrowserActionsContainer::Paint(gfx::Canvas* canvas) {
   // The one-pixel themed vertical divider to the right of the browser actions.
   int x = UILayoutIsRightToLeft() ? kDividerHorizontalMargin :
                                     width() - kDividerHorizontalMargin;
   DetachableToolbarView::PaintVerticalDivider(
       canvas, x, height(), kDividerVerticalPadding,
       DetachableToolbarView::kEdgeDividerColor,
       DetachableToolbarView::kMiddleDividerColor,
       GetThemeProvider()->GetColor(BrowserThemeProvider::COLOR_TOOLBAR));
+
+  // The two-pixel width drop indicator.
+  if (drop_indicator_position_ > -1) {
+    x = drop_indicator_position_;
+    int y = kDividerVerticalPadding;
+    gfx::Rect indicator_bounds(x - kDropIndicatorWidth / 2,
+                               y,
+                               kDropIndicatorWidth,
+                               height() - (2 * kDividerVerticalPadding));
+
+    // TODO(sky/glen): make me pretty!
+    canvas->FillRectInt(kDropIndicatorColor, indicator_bounds.x(),
+                        indicator_bounds.y(), indicator_bounds.width(),
+                        indicator_bounds.height());
+  }
 }
 
 void BrowserActionsContainer::ViewHierarchyChanged(bool is_add,
                                                    views::View* parent,
                                                    views::View* child) {
   // No extensions (e.g., incognito).
   if (!model_)
     return;
 
   if (is_add && child == this) {
     // Initial toolbar button creation and placement in the widget hierarchy.
     // We do this here instead of in the constructor because AddBrowserAction
     // calls Layout on the Toolbar, which needs this object to be constructed
     // before its Layout function is called.
-    for (ExtensionList::iterator iter = model_->begin();
-        iter != model_->end(); ++iter) {
-      BrowserActionView* view = new BrowserActionView(*iter, this);
-      browser_action_views_.push_back(view);
-      AddChildView(view);
-    }
+    CreateBrowserActionViews();
   }
 }
 
+bool BrowserActionsContainer::GetDropFormats(
+    int* formats, std::set<OSExchangeData::CustomFormat>* custom_formats) {
+  custom_formats->insert(BrowserActionDragData::GetBrowserActionCustomFormat());
+  return true;
+}
+
+bool BrowserActionsContainer::AreDropTypesRequired() {
+  return true;
+}
+
+bool BrowserActionsContainer::CanDrop(const OSExchangeData& data) {
+  BrowserActionDragData drop_data;
+  if (!drop_data.Read(data))
+    return false;
+  return drop_data.IsFromProfile(profile_);
+}
+
+void BrowserActionsContainer::OnDragEntered(
+    const views::DropTargetEvent& event) {
+}
+
+int BrowserActionsContainer::OnDragUpdated(
+    const views::DropTargetEvent& event) {
+  // 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 -
+      (UILayoutIsRightToLeft() ? kDropIndicatorOffsetRtl :
+                                 kDropIndicatorOffsetLtr);
+
+  SchedulePaint();
+  return DragDropTypes::DRAG_MOVE;
+}
+
+void BrowserActionsContainer::OnDragExited() {
+  drop_indicator_position_ = -1;
+  SchedulePaint();
+}
+
+int BrowserActionsContainer::OnPerformDrop(
+    const views::DropTargetEvent& event) {
+  BrowserActionDragData data;
+  if (!data.Read(event.GetData()))
+    return DragDropTypes::DRAG_NONE;
+
+  // Make sure we have the same view as we started with.
+  DCHECK(browser_action_views_[data.index()]->button()->extension()->id() ==
+         data.id());
+
+  Extension* dragging =
+      browser_action_views_[data.index()]->button()->extension();
+
+  int target_x = drop_indicator_position_;
+
+  size_t i = 0;
+  for (; i < browser_action_views_.size(); ++i) {
+    int view_x =
+        browser_action_views_[i]->GetBounds(APPLY_MIRRORING_TRANSFORMATION).x();
+    if (!browser_action_views_[i]->IsVisible() ||
+        (UILayoutIsRightToLeft() ? view_x < target_x : view_x >= target_x)) {
+      // We have reached the end of the visible icons or found one that has a
+      // higher x position than the drop point.
+      break;
+    }
+  }
+
+  // |i| now points to the item to the right of the drop indicator*, which is
+  // correct when dragging an icon to the left. When dragging to the right,
+  // however, we want the icon being dragged to get the index of the item to
+  // the left of the drop indicator, so we subtract one.
+  // * 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::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 47 matching lines @@
 }
 
 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());
   }
 }
 
-int BrowserActionsContainer::ClampToNearestIconCount(int pixelWidth) const {
+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(
+          browser_action_views_[i]->button()->extension()->id(), i);
+      drag_data.Write(profile_, data);
+      break;
+    }
+  }
+}
+
+int BrowserActionsContainer::GetDragOperations(View* sender, int x, int y) {
+  return DragDropTypes::DRAG_MOVE;
+}
+
+bool BrowserActionsContainer::CanStartDrag(
+    View* sender, int press_x, int press_y, int x, int y) {
+  return true;
+}
+
+int BrowserActionsContainer::ClampToNearestIconCount(
+    int pixelWidth, bool allow_shrink_to_minimum) const {
   // Calculate the width of one icon.
   int icon_width = (kButtonSize + kBrowserActionButtonPadding);
 
   // Calculate pixel count for the area not used by the icons.
   int extras = WidthOfNonIconArea();
 
   size_t icon_count = 0u;
   if (pixelWidth >= 0) {
     // Caller wants to know how many icons fit within a given space so we start
     // by subtracting the padding, gripper and dividers.
     int icon_area = pixelWidth - extras;
     icon_area = std::max(0, icon_area);
 
     // Make sure we never throw an icon into the chevron menu just because
     // there isn't enough enough space for the invisible padding around buttons.
     icon_area += kBrowserActionButtonPadding - 1;
 
     // Count the number of icons that fit within that area.
     icon_count = icon_area / icon_width;
 
-    // No use allowing more than what we have.
-    if (icon_count > browser_action_views_.size())
+    if (icon_count == 0 && allow_shrink_to_minimum) {
+      extras = ContainerMinSize();  // Allow very narrow width if no icons.
+    } else if (icon_count > browser_action_views_.size()) {
+      // No use allowing more than what we have.
       icon_count = browser_action_views_.size();
-    else if (icon_count == 0)
-      extras = ContainerMinSize();  // Allow very narrow width if no icons.
+    }
   } else {
     // A negative |pixels| count indicates caller wants to know the max width
     // that fits all icons;
     icon_count = browser_action_views_.size();
   }
 
-  int returning = extras + (icon_count * icon_width);
-  return returning;
+  return extras + (icon_count * icon_width);
 }
 
 void BrowserActionsContainer::BrowserActionAdded(Extension* extension,
                                                  int index) {
 #if defined(DEBUG)
   for (size_t i = 0; i < browser_action_views_.size(); ++i) {
     DCHECK(browser_action_views_[i]->button()->extension() != extension) <<
            "Asked to add a browser action view for an extension that already "
            "exists.";
   }
@@ skipping 52 matching lines @@
 
       // For details on why we do the following see the class comments in the
       // header.
 
       // Calculate the target size we'll animate to (end state). This might be
       // the same size (if the icon we are removing is in the overflow bucket
       // and there are other icons there). We don't decrement visible_actions
       // because we want the container to stay the same size (clamping will take
       // care of shrinking the container if there aren't enough icons to show).
       animation_target_size_ =
-          ClampToNearestIconCount(IconCountToWidth(visible_actions));
+          ClampToNearestIconCount(IconCountToWidth(visible_actions), true);
 
       // Animate!
       resize_animation_->Reset();
       resize_animation_->SetTweenType(SlideAnimation::EASE_OUT);
       resize_animation_->Show();
       return;
     }
   }
 }
 
+void BrowserActionsContainer::BrowserActionMoved(Extension* extension,
+                                                 int index) {
+  DCHECK(index >= 0 && index < static_cast<int>(browser_action_views_.size()));
+
+  DeleteBrowserActionViews();
+  CreateBrowserActionViews();
+  Layout();
+}
+
 int BrowserActionsContainer::WidthOfNonIconArea() const {
   int chevron_size = (chevron_->IsVisible()) ?
                      chevron_->GetPreferredSize().width() : 0;
-  return resize_gripper_->GetPreferredSize().width() + kHorizontalPadding +
+  int padding = UILayoutIsRightToLeft() ? kHorizontalPaddingRtl :
+                                          kHorizontalPadding;
+  return resize_gripper_->GetPreferredSize().width() + padding +
          chevron_size + kChevronRightMargin + kDividerHorizontalMargin;
 }
 
 int BrowserActionsContainer::IconCountToWidth(int icons) const {
   DCHECK(icons >= 0);
   if (icons == 0)
     return ContainerMinSize();
 
   int icon_width = kButtonSize + kBrowserActionButtonPadding;
 
@@ skipping 18 matching lines @@
   if (!done_resizing) {
     resize_amount_ = resize_amount;
     OnBrowserActionVisibilityChanged();
   } else {
     // For details on why we do the following see the class comments in the
     // header.
 
     // Clamp lower limit to 0 and upper limit to the amount that allows enough
     // room for all icons to show.
     int new_width = std::max(0, container_size_.width() - resize_amount);
-    int max_width = ClampToNearestIconCount(-1);
+    int max_width = ClampToNearestIconCount(-1, false);
     new_width = std::min(new_width, max_width);
 
     // Up until now we've only been modifying the resize_amount, but now it is
     // time to set the container size to the size we have resized to, but then
     // animate to the nearest icon count size (or down to min size if no icon).
     container_size_.set_width(new_width);
-    animation_target_size_ = ClampToNearestIconCount(new_width);
+    animation_target_size_ = ClampToNearestIconCount(new_width, true);
     resize_animation_->Reset();
     resize_animation_->SetTweenType(SlideAnimation::EASE_OUT);
     resize_animation_->Show();
   }
 }
 
 void BrowserActionsContainer::AnimationProgressed(const Animation* animation) {
   DCHECK(animation == resize_animation_.get());
 
   double e = resize_animation_->GetCurrentValue();
   int difference = container_size_.width() - animation_target_size_;
 
   resize_amount_ = static_cast<int>(e * difference);
 
   OnBrowserActionVisibilityChanged();
 }
 
 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());
 }