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_);
 }
 
 void DockedPanelStrip::SetDisplayArea(const gfx::Rect& display_area) {
   if (display_area_ == display_area)
     return;
 
   gfx::Rect old_area = display_area_;
   display_area_ = display_area;
@@ skipping 95 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);
 }
 
 int DockedPanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
 
 int DockedPanelStrip::StartingRightPosition() const {
   return display_area_.right();
 }
 
 int DockedPanelStrip::GetRightMostAvailablePosition() const {
   return panels_.empty() ? StartingRightPosition() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
 bool DockedPanelStrip::RemovePanel(Panel* panel) {
+  bool refresh_layout = !disable_layout_refresh_;
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
-    return true;
+    refresh_layout = false;

[jennb, 2012/02/17 21:28:45]

Keep this 'return true'. No need for refresh_layout temp var.

[jianli, 2012/02/17 23:52:56]

Per discussion, remove the change from this patch.

+  } else {
+    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);
   }
 
-  if (find(panels_.begin(), panels_.end(), panel) == panels_.end())
-    return false;
+  panel_manager_->OnPanelRemoved(panel);

[jennb, 2012/02/17 21:28:45]

Move this right after erase(iter) so notification is only sent out for regular
docked panels. Don't change existing behavior in this patch.

[jianli, 2012/02/17 23:52:56]

Per discussion, remove the change from this patch.

 
-  // If we're in the process of dragging, delay the removal.
-  if (dragging_panel_) {
-    panels_pending_to_remove_.push_back(panel);
-    return true;
-  }
-
-  DoRemove(panel);
-
-  if (!disable_layout_refresh_)
+  if (refresh_layout)
     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::CanDragPanel(Panel* panel) const {
+  // Only the panels having temporary layout can't be dragged.
+  return !panel->has_temporary_layout();
 }
 
-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) {
+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(int delta_x, int delta_y) {
   if (!delta_x)
     return;
 
+  Panel* dragging_panel = panel_manager_->drag_controller()->dragging_panel();
+  DCHECK(dragging_panel);
+
   // Moves this panel to the dragging position.
-  gfx::Rect new_bounds(dragging_panel_->GetBounds());
+  gfx::Rect new_bounds(dragging_panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
-  dragging_panel_->SetPanelBounds(new_bounds);
+  dragging_panel->SetPanelBounds(new_bounds);
 
   // Checks and processes other affected panels.
   if (delta_x > 0)
-    DragRight();
+    DragRight(dragging_panel);
   else
-    DragLeft();
+    DragLeft(dragging_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(bool cancelled) {
+  Panel* dragging_panel = panel_manager_->drag_controller()->dragging_panel();
+  DCHECK(dragging_panel);
 
   if (cancelled)
-    Drag(dragging_panel_original_x_ - dragging_panel_->GetBounds().x());
+    DragPanel(dragging_panel_original_x_ - dragging_panel->GetBounds().x(), 0);
   else
-    dragging_panel_->SetPanelBounds(dragging_panel_bounds_);
-
-  dragging_panel_ = NULL;
-
-  DelayedRemove();
+    dragging_panel->SetPanelBounds(dragging_panel_bounds_);
 }
 
 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:
       if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
         DecrementMinimizedPanels();
@@ skipping 137 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())
-      return true;
+    if (state == Panel::TITLE_ONLY) {
+      Panel* dragging_panel =

[jennb, 2012/02/17 21:28:45]

shouldn't this be:

if (state == title_only && drag_controller()->dragging_panel() == panel)
  return true?

[jianli, 2012/02/17 23:52:56]

Done.

+          panel_manager_->drag_controller()->dragging_panel();
+      if (dragging_panel && dragging_panel->panel_strip() == this)
+        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())
       return true;
@@ skipping 198 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;
-}