Support detaching/attaching panels via inter-strip drags.

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 <vector>
 
 #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),
+      panel_to_restore_after_on_drag_cancelled_(NULL),
       delayed_titlebar_action_(NO_ACTION),
       titlebar_action_factory_(this) {
-  dragging_panel_current_iterator_ = dragging_panel_original_iterator_ =
-      panels_.end();
+  dragging_panel_current_iterator_ = panels_.end();
 }
 
 DockedPanelStrip::~DockedPanelStrip() {
   DCHECK(panels_.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)
@@ skipping 16 matching lines @@
   int max_panel_width = GetMaxPanelWidth();
   int max_panel_height = GetMaxPanelHeight();
   panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
                       gfx::Size(max_panel_width, max_panel_height));
 
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
 
   if (panel->initialized()) {
-    // Bump panels in the strip to make room for this panel.
-    // Prevent layout refresh when panel is removed from this strip.
-    disable_layout_refresh_ = true;
-    PanelStrip* overflow_strip = panel_manager_->overflow_strip();
-    int x;
-    while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
-      DCHECK(!panels_.empty());
-      panels_.back()->MoveToStrip(overflow_strip);
-    }
-    disable_layout_refresh_ = false;
+    // Make sure we have sufficient space for this panel. We might bump
+    // panels in the strip to make room for this panel.
+    EnsureEnoughSpaceForPanel(width);
+    int x = GetRightMostAvailablePosition() - width;
 
     Panel::ExpansionState expansion_state_to_restore;
     if (panel->expansion_state() == Panel::EXPANDED) {
       expansion_state_to_restore = Panel::EXPANDED;
     } else {
       if (are_titlebars_up_ || panel->IsDrawingAttention()) {
         expansion_state_to_restore = Panel::TITLE_ONLY;
         height = panel->TitleOnlyHeight();
       } else {
         expansion_state_to_restore = Panel::MINIMIZED;
@@ skipping 56 matching lines @@
 
   // Set panel properties for this strip.
   panel->SetAppIconVisibility(true);
 
   if (panel->has_temporary_layout())
     panels_in_temporary_layout_.insert(panel);
   else
     panels_.push_back(panel);
 }
 
+void DockedPanelStrip::AddPanelAtPosition(Panel* panel,
+                                          const gfx::Point& position) {
+  // First, make sure we have sufficient space for this panel. We might bump
+  // panels in the strip to make room for this panel.
+  EnsureEnoughSpaceForPanel(panel->GetBounds().width());
+
+  // Set panel properties for this strip.

[jennb, 2012/03/01 00:33:38]

Wish this method and AddPanels() could be consolidated more. It's easy to mess
up panel properties with it being set in both methods.

[jianli, 2012/03/02 22:42:43]

I agree but it will involve quite a bit of refactoring and add up the complexity
to this patch. I would do it in another patch.

+  panel->SetAppIconVisibility(true);
+
+  // Then, find and insert this panel to the right position.
+  int x = position.x();
+  Panels::iterator iter = panels_.begin();
+  for (; iter != panels_.end(); ++iter) {
+    Panel* current_panel = *iter;
+    gfx::Rect current_bounds = current_panel->GetBounds();
+    if (x > current_bounds.x())
+      break;
+  }
+  panels_.insert(iter, panel);
+
+  gfx::Rect new_bounds(panel->GetBounds());

[jennb, 2012/03/01 00:33:38]

Won't refresh layout update the panel bounds correctly? No need for these 3
lines.

[jianli, 2012/03/02 22:42:43]

RefreshLayout will not update the dragging panel. See if check in that function.
When we drag a panel around, it be moved anywhere and we do not want
RefreshLayout to update it with its "finalized" bounds.

+  new_bounds.set_origin(position);
+  panel->SetPanelBounds(new_bounds);
+
+  // This will automatically update all affected panels due to the insertion.
+  RefreshLayout();
+}
+
+void DockedPanelStrip::EnsureEnoughSpaceForPanel(int width) {
+  // Prevent layout refresh when panel is removed from this strip.
+  disable_layout_refresh_ = true;
+  PanelStrip* overflow_strip = panel_manager_->overflow_strip();
+  int x;
+  while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
+    DCHECK(!panels_.empty());
+    panels_.back()->MoveToStrip(overflow_strip);
+  }
+  disable_layout_refresh_ = false;
+}
+
 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();
@@ skipping 11 matching lines @@
   }
 
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
   // Removing an element from the list will invalidate the iterator that refers
-  // to it. So we need to check if the dragging panel iterators are affected.
-  bool update_original_dragging_iterator_after_erase = false;
-  if (dragging_panel_original_iterator_ != panels_.end()) {
-    if (dragging_panel_current_iterator_ == iter) {
-      // If the dragging panel is being removed, set both dragging iterators to
-      // the end of the list.
-      dragging_panel_current_iterator_ = dragging_panel_original_iterator_ =
-          panels_.end();
-    } else if (dragging_panel_original_iterator_ == iter) {
-      // If |dragging_panel_original_iterator_| refers to the element being
-      // removed, set the flag so that the iterator can be updated to next
-      // element.
-      update_original_dragging_iterator_after_erase = true;
-    }
-  }
+  // to it. If the dragging panel is being removed, set the dragging iterator to
+  // the end of the list.
+  if (dragging_panel_current_iterator_ == iter)
+    dragging_panel_current_iterator_ = panels_.end();
 
   iter = panels_.erase(iter);
 
-  if (update_original_dragging_iterator_after_erase)
-    dragging_panel_original_iterator_ = iter;
+  // If |panel_to_restore_after_on_drag_cancelled_| is removed, update it to
+  // the next panel after the panel being removed.
+  if (panel == panel_to_restore_after_on_drag_cancelled_) {
+    panel_to_restore_after_on_drag_cancelled_ =
+        (iter == panels_.end()) ? NULL : *iter;
+  }
 
   if (!disable_layout_refresh_)
     RefreshLayout();
 
   return true;
 }
 
 bool DockedPanelStrip::CanShowPanelAsActive(const Panel* panel) const {
   // Panels with temporary layout cannot be shown as active.
   return !panel->has_temporary_layout();
 }
 
 bool DockedPanelStrip::CanDragPanel(const Panel* panel) const {
   // Only the panels having temporary layout can't be dragged.
   return !panel->has_temporary_layout();
 }
 
 Panel* DockedPanelStrip::dragging_panel() const {
-  return dragging_panel_current_iterator_ == panels_.end() ? NULL :
-      *dragging_panel_current_iterator_;
+  Panel* dragging_panel = panel_manager_->drag_controller()->dragging_panel();
+  return (dragging_panel && dragging_panel->panel_strip() == this) ?
+      dragging_panel : NULL;
 }
 
 void DockedPanelStrip::StartDraggingPanel(Panel* panel) {
   dragging_panel_current_iterator_ =
       find(panels_.begin(), panels_.end(), panel);
   DCHECK(dragging_panel_current_iterator_ != panels_.end());
-  dragging_panel_original_iterator_ = dragging_panel_current_iterator_;
+
+  // Remember the panel to restore after. We only need to do it once when the
+  // dragging panel does not leave the docked strip.
+  if (!panel_manager_->drag_controller()->has_dragged_to_other_strip()) {
+    panel_to_restore_after_on_drag_cancelled_ =
+        GetNextPanel(dragging_panel_current_iterator_);
+  }
 }
 
 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(panel->GetBounds());
   new_bounds.set_x(new_bounds.x() + delta_x);
   panel->SetPanelBounds(new_bounds);
@@ skipping 57 matching lines @@
     // Swaps the contents and makes |dragging_panel_current_iterator_| refers
     // to the new position.
     *dragging_panel_current_iterator_ = current_panel;
     *current_panel_iterator = dragging_panel;
     dragging_panel_current_iterator_ = current_panel_iterator;
   }
 }
 
 void DockedPanelStrip::EndDraggingPanel(Panel* panel, bool cancelled) {
   if (cancelled) {
-    if (dragging_panel_current_iterator_ != dragging_panel_original_iterator_) {
-      // Find out if the dragging panel should be moved toward the end/beginning
-      // of the list.
-      bool move_towards_end_of_list = true;
-      for (Panels::iterator iter = dragging_panel_original_iterator_;
-           iter != panels_.end(); ++iter) {
-        if (iter == dragging_panel_current_iterator_) {
-          move_towards_end_of_list = false;
-          break;
-        }
-      }
+    Panels::iterator next_iter = dragging_panel_current_iterator_;
+    ++next_iter;
+    if (panel_to_restore_after_on_drag_cancelled_ !=
+        GetNextPanel(dragging_panel_current_iterator_)) {
+      // Remove the dragging panel from current position.
+      panels_.erase(dragging_panel_current_iterator_);
 
-      // Move the dragging panel back to its original position by swapping it
-      // with its adjacent element until it reach its original position.
-      while (dragging_panel_current_iterator_ !=
-             dragging_panel_original_iterator_) {
-        Panels::iterator next_iter = dragging_panel_current_iterator_;
-        if (move_towards_end_of_list)
-          ++next_iter;
-        else
-          --next_iter;
-        iter_swap(dragging_panel_current_iterator_, next_iter);
-        dragging_panel_current_iterator_ = next_iter;
+      // Insert the dragging panel to the restore position.
+      if (panel_to_restore_after_on_drag_cancelled_) {
+        Panels::iterator iter_to_restore_after = std::find(panels_.begin(),
+            panels_.end(), panel_to_restore_after_on_drag_cancelled_);
+        DCHECK(iter_to_restore_after != panels_.end());
+        panels_.insert(iter_to_restore_after, panel);
+      } else {
+        panels_.push_back(panel);
       }
     }
   }
 
-  dragging_panel_current_iterator_ = dragging_panel_original_iterator_ =
-      panels_.end();
+  dragging_panel_current_iterator_ = panels_.end();
 
   RefreshLayout();
 }
 
 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 364 matching lines @@
   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();
 }
+
+Panel* DockedPanelStrip::GetNextPanel(const Panels::iterator& iter) const {
+  DCHECK(iter != panels_.end());
+  Panels::iterator next_iter = iter;
+  ++next_iter;
+  return (next_iter == panels_.end()) ? NULL : *next_iter;
+}