Refactor intra-strip panel drags by introducing PanelDragController.

chrome/browser/ui/panels/docked_panel_strip.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 "chrome/browser/ui/panels/docked_panel_strip.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/overflow_panel_strip.h"
+#include "chrome/browser/ui/panels/panel_drag_controller.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_mouse_watcher.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 namespace {
 // Width to height ratio is used to compute the default width or height
 // when only one value is provided.
 const double kPanelDefaultWidthToHeightRatio = 1.62;  // golden ratio
@@ skipping 28 matching lines @@
 // static
 const int DockedPanelStrip::kPanelMinWidth = 100;
 const int DockedPanelStrip::kPanelMinHeight = 20;
 
 DockedPanelStrip::DockedPanelStrip(PanelManager* panel_manager)
     : PanelStrip(PanelStrip::DOCKED),
       panel_manager_(panel_manager),
       minimized_panel_count_(0),
       are_titlebars_up_(false),
       disable_layout_refresh_(false),
-      dragging_panel_(NULL),
       dragging_panel_original_x_(0),
       delayed_titlebar_action_(NO_ACTION),
       titlebar_action_factory_(this) {
 }
 
 DockedPanelStrip::~DockedPanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK(panels_in_temporary_layout_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
@@ skipping 103 matching lines @@
                      panel),
           base::TimeDelta::FromMilliseconds(PanelManager::AdjustTimeInterval(
               kMoveNewPanelToOverflowDelayMs)));
     }
 #endif
     panel->Initialize(gfx::Rect(x, y, width, height));
   }
 
   // Set panel properties for this strip.
   panel->SetAppIconVisibility(true);
-  panel->set_draggable(!panel->has_temporary_layout());
   panel->ApplyVisualStyleForStrip();
 
   if (panel->has_temporary_layout())
     panels_in_temporary_layout_.insert(panel);
   else
     panels_.push_back(panel);
 }
 
 int DockedPanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
@@ skipping 15 matching lines @@
 bool DockedPanelStrip::RemovePanel(Panel* panel) {
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
     return true;
   }
 
   if (find(panels_.begin(), panels_.end(), panel) == panels_.end())
     return false;
 
   // If we're in the process of dragging, delay the removal.
-  if (dragging_panel_) {
+  if (panel_manager_->drag_controller()->dragging_panel()) {

[jennb, 2012/02/21 20:01:46]

nit: should there be a IsDragging()/DragInProgress() method on drag controller?

     panels_pending_to_remove_.push_back(panel);
     return true;
   }
-
   DoRemove(panel);
 
   if (!disable_layout_refresh_)
     RefreshLayout();
 
   return true;
 }
 
 void DockedPanelStrip::DelayedRemove() {
   for (size_t i = 0; i < panels_pending_to_remove_.size(); ++i)
     DoRemove(panels_pending_to_remove_[i]);
   panels_pending_to_remove_.clear();
   RefreshLayout();
 }
 
 bool DockedPanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
   panels_.erase(iter);
   panel_manager_->OnPanelRemoved(panel);
   return true;
 }
 
-void DockedPanelStrip::StartDragging(Panel* panel) {
+bool DockedPanelStrip::CanDragPanel(const Panel* panel) const {
+  // Only the panels having temporary layout can't be dragged.
+  return !panel->has_temporary_layout();
+}
+
+void DockedPanelStrip::StartDraggingPanel(Panel* panel) {
   dragging_panel_iterator_ = find(panels_.begin(), panels_.end(), panel);
   DCHECK(dragging_panel_iterator_ != panels_.end());
 
-  dragging_panel_ = panel;
   dragging_panel_bounds_ = panel->GetBounds();
   dragging_panel_original_x_ = dragging_panel_bounds_.x();
 }
 
-void DockedPanelStrip::Drag(int delta_x) {
-  DCHECK(dragging_panel_);
-
+void DockedPanelStrip::DragPanel(Panel* panel, int delta_x, int delta_y) {
   if (!delta_x)
     return;
 
   // Moves this panel to the dragging position.
-  gfx::Rect new_bounds(dragging_panel_->GetBounds());
+  gfx::Rect new_bounds(panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
-  dragging_panel_->SetPanelBounds(new_bounds);
+  panel->SetPanelBounds(new_bounds);
 
   // Checks and processes other affected panels.
   if (delta_x > 0)
-    DragRight();
+    DragRight(panel);
   else
-    DragLeft();
+    DragLeft(panel);
 }
 
-void DockedPanelStrip::DragLeft() {
+void DockedPanelStrip::DragLeft(Panel* dragging_panel) {
   // This is the left corner of the dragging panel. We use it to check against
   // all the panels on its left.
-  int dragging_panel_left_boundary = dragging_panel_->GetBounds().x();
+  int dragging_panel_left_boundary = dragging_panel->GetBounds().x();
 
   // This is the right corner which a panel will be moved to.
   int current_panel_right_boundary =
       dragging_panel_bounds_.x() + dragging_panel_bounds_.width();
 
   // Checks the panels to the left of the dragging panel.
   Panels::iterator current_panel_iterator = dragging_panel_iterator_;
   ++current_panel_iterator;
   for (; current_panel_iterator != panels_.end(); ++current_panel_iterator) {
     Panel* current_panel = *current_panel_iterator;
 
     // Current panel will only be affected if the left corner of dragging
     // panel goes beyond the middle position of the current panel.
     if (dragging_panel_left_boundary > current_panel->GetBounds().x() +
             current_panel->GetBounds().width() / 2)
       break;
 
     // Moves current panel to the new position.
     gfx::Rect bounds(current_panel->GetBounds());
     bounds.set_x(current_panel_right_boundary - bounds.width());
     current_panel_right_boundary -= bounds.width() + kPanelsHorizontalSpacing;
     current_panel->SetPanelBounds(bounds);
 
     // Swaps current panel and dragging panel.
     *dragging_panel_iterator_ = current_panel;
-    *current_panel_iterator = dragging_panel_;
+    *current_panel_iterator = dragging_panel;
     dragging_panel_iterator_ = current_panel_iterator;
   }
 
   // Updates the potential final position of dragging panel as the result of
   // swapping with panels on its left.
   dragging_panel_bounds_.set_x(current_panel_right_boundary -
                                dragging_panel_bounds_.width());
 }
 
-void DockedPanelStrip::DragRight() {
+void DockedPanelStrip::DragRight(Panel* dragging_panel) {
   // This is the right corner of the dragging panel. We use it to check against
   // all the panels on its right.
-  int dragging_panel_right_boundary = dragging_panel_->GetBounds().x() +
-      dragging_panel_->GetBounds().width() - 1;
+  int dragging_panel_right_boundary = dragging_panel->GetBounds().x() +
+      dragging_panel->GetBounds().width() - 1;
 
   // This is the left corner which a panel will be moved to.
   int current_panel_left_boundary = dragging_panel_bounds_.x();
 
   // Checks the panels to the right of the dragging panel.
   Panels::iterator current_panel_iterator = dragging_panel_iterator_;
   while (current_panel_iterator != panels_.begin()) {
     current_panel_iterator--;
     Panel* current_panel = *current_panel_iterator;
 
     // Current panel will only be affected if the right corner of dragging
     // panel goes beyond the middle position of the current panel.
     if (dragging_panel_right_boundary < current_panel->GetBounds().x() +
             current_panel->GetBounds().width() / 2)
       break;
 
     // Moves current panel to the new position.
     gfx::Rect bounds(current_panel->GetBounds());
     bounds.set_x(current_panel_left_boundary);
     current_panel_left_boundary += bounds.width() + kPanelsHorizontalSpacing;
     current_panel->SetPanelBounds(bounds);
 
     // Swaps current panel and dragging panel.
     *dragging_panel_iterator_ = current_panel;
-    *current_panel_iterator = dragging_panel_;
+    *current_panel_iterator = dragging_panel;
     dragging_panel_iterator_ = current_panel_iterator;
   }
 
   // Updates the potential final position of dragging panel as the result of
   // swapping with panels on its right.
   dragging_panel_bounds_.set_x(current_panel_left_boundary);
 }
 
-void DockedPanelStrip::EndDragging(bool cancelled) {
-  DCHECK(dragging_panel_);
-
+void DockedPanelStrip::EndDraggingPanel(Panel* panel, bool cancelled) {
   if (cancelled)
-    Drag(dragging_panel_original_x_ - dragging_panel_->GetBounds().x());
+    DragPanel(panel, dragging_panel_original_x_ - panel->GetBounds().x(), 0);
   else
-    dragging_panel_->SetPanelBounds(dragging_panel_bounds_);
-
-  dragging_panel_ = NULL;
+    panel->SetPanelBounds(dragging_panel_bounds_);
 
   DelayedRemove();
 }
 
 void DockedPanelStrip::OnPanelExpansionStateChanged(Panel* panel) {
   gfx::Size size = panel->restored_size();
   Panel::ExpansionState expansion_state = panel->expansion_state();
   Panel::ExpansionState old_state = panel->old_expansion_state();
   switch (expansion_state) {
     case Panel::EXPANDED:
@@ skipping 139 matching lines @@
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
     Panel::ExpansionState state = panel->expansion_state();
     // Skip the expanded panel.
     if (state == Panel::EXPANDED)
       continue;
 
     // If the panel is showing titlebar only, we want to keep it up when it is
     // being dragged.
-    if (state == Panel::TITLE_ONLY && is_dragging_panel())
+    if (state == Panel::TITLE_ONLY &&
+        panel == panel_manager_->drag_controller()->dragging_panel())
       return true;
 
     // We do not want to bring up other minimized panels if the mouse is over
     // the panel that pops up the titlebar to attract attention.
     if (panel->IsDrawingAttention())
       continue;
 
     gfx::Rect bounds = panel->GetBounds();
     if (bounds.x() <= mouse_x && mouse_x <= bounds.right() &&
         mouse_y >= bounds.y())
@@ skipping 199 matching lines @@
 
 void DockedPanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
       DCHECK(panel->has_temporary_layout());
       panel->MoveToStrip(panel_manager_->overflow_strip());
   }
 }
 
 void DockedPanelStrip::CloseAll() {
   // This should only be called at the end of tests to clean up.
-  DCHECK(!dragging_panel_);
   DCHECK(panels_in_temporary_layout_.empty());
 
   // Make a copy of the iterator as closing panels can modify the vector.
   Panels panels_copy = panels_;
 
   // Start from the bottom to avoid reshuffling.
   for (Panels::reverse_iterator iter = panels_copy.rbegin();
        iter != panels_copy.rend(); ++iter)
     (*iter)->Close();
 }
-
-bool DockedPanelStrip::is_dragging_panel() const {
-  return dragging_panel_ != NULL;
-}