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 29 matching lines @@
 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),
       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)
     return;
 
   gfx::Rect old_area = display_area_;
   display_area_ = display_area;
 
   if (panels_.empty())
     return;
 
   RefreshLayout();
 }
 
 void DockedPanelStrip::AddPanel(Panel* panel) {
   DCHECK_NE(this, panel->panel_strip());
   panel->set_panel_strip(this);
 
+  if (panel->initialized()) {

[jennb, 2012/03/08 23:41:09]

if (panel !initialized)
  insert newly created
else if (preview mode)
  insert preview
else
  insert existing

Easier to read than nested ifs.

[jianli, 2012/03/09 21:48:58]

Done.

+    if (panel->in_preview_mode())
+      InsertPreviewedPanel(panel);
+    else
+      InsertExistingPanel(panel);
+  } else {
+    InsertNewlyCreatedPanel(panel);
+  }
+
   // Always update limits, even on existing panels, in case the limits changed
   // while panel was out of the strip.
   int max_panel_width = GetMaxPanelWidth();
   int max_panel_height = GetMaxPanelHeight();
   panel->SetSizeRange(gfx::Size(kPanelMinWidth, kPanelMinHeight),
                       gfx::Size(max_panel_width, max_panel_height));
 
+  panel->SetAppIconVisibility(true);
+  panel->SetAlwaysOnTop(true);
+}
+
+

[jennb, 2012/03/08 23:41:09]

Extra blank line.

[jianli, 2012/03/09 21:48:58]

Done.

+void DockedPanelStrip::InsertPreviewedPanel(Panel* panel) {
+  DCHECK(panel->initialized() && panel->in_preview_mode());
+
+  FitPanelWithWidth(panel->GetBounds().width());
+
+  int x = panel->GetBounds().x();
+  Panels::iterator iter = panels_.begin();
+  for (; iter != panels_.end(); ++iter)
+    if (x > (*iter)->GetBounds().x())
+      break;
+  panels_.insert(iter, panel);
+
+  // This will automatically update all affected panels due to the insertion.
+  if (iter != panels_.end())
+    RefreshLayout();
+}
+
+void DockedPanelStrip::InsertExistingPanel(Panel* panel) {
+  DCHECK(panel->initialized() && !panel->in_preview_mode());
+
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
 
-  if (panel->initialized()) {
-    int x = FitPanelWithWidth(width);
+  int x = FitPanelWithWidth(width);
 
-    Panel::ExpansionState expansion_state_to_restore;
-    if (panel->expansion_state() == Panel::EXPANDED) {
-      expansion_state_to_restore = Panel::EXPANDED;
+  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 {
-      if (are_titlebars_up_ || panel->IsDrawingAttention()) {
-        expansion_state_to_restore = Panel::TITLE_ONLY;
-        height = panel->TitleOnlyHeight();
-      } else {
-        expansion_state_to_restore = Panel::MINIMIZED;
-        height = Panel::kMinimizedPanelHeight;
-      }
-      IncrementMinimizedPanels();
+      expansion_state_to_restore = Panel::MINIMIZED;
+      height = Panel::kMinimizedPanelHeight;
     }
-    int y =
-        GetBottomPositionForExpansionState(expansion_state_to_restore) - height;
-    panel->SetPanelBounds(gfx::Rect(x, y, width, height));
+    IncrementMinimizedPanels();
+  }
+  int y =
+      GetBottomPositionForExpansionState(expansion_state_to_restore) - height;
+  panel->SetPanelBounds(gfx::Rect(x, y, width, height));
 
-    // Update the minimized state to reflect current titlebar mode.
-    // Do this AFTER setting panel bounds to avoid an extra bounds change.
-    if (panel->expansion_state() != Panel::EXPANDED)
-      panel->SetExpansionState(expansion_state_to_restore);
+  // Update the minimized state to reflect current titlebar mode.
+  // Do this AFTER setting panel bounds to avoid an extra bounds change.
+  if (panel->expansion_state() != Panel::EXPANDED)
+    panel->SetExpansionState(expansion_state_to_restore);
 
+  panels_.push_back(panel);
+}
+
+void DockedPanelStrip::InsertNewlyCreatedPanel(Panel* panel) {
+  DCHECK(!panel->initialized());
+
+  int max_panel_width = GetMaxPanelWidth();
+  int max_panel_height = GetMaxPanelHeight();
+  gfx::Size restored_size = panel->restored_size();
+  int height = restored_size.height();
+  int width = restored_size.width();
+
+  // Initialize the newly created panel. Does not bump any panels from strip.
+  if (height == 0 && width == 0 && panel_manager_->auto_sizing_enabled()) {
+    // Auto resizable is enabled only if no initial size is provided.
+    panel->SetAutoResizable(true);
   } else {
-    // Initialize the newly created panel. Does not bump any panels from strip.
-    if (height == 0 && width == 0 && panel_manager_->auto_sizing_enabled()) {
-      // Auto resizable is enabled only if no initial size is provided.
-      panel->SetAutoResizable(true);
-    } else {
-      if (height == 0)
-        height = width / kPanelDefaultWidthToHeightRatio;
-      if (width == 0)
-        width = height * kPanelDefaultWidthToHeightRatio;
-    }
-
-    // Constrain sizes to limits.
-    if (width < kPanelMinWidth)
-      width = kPanelMinWidth;
-    else if (width > max_panel_width)
-      width = max_panel_width;
-
-    if (height < kPanelMinHeight)
-      height = kPanelMinHeight;
-    else if (height > max_panel_height)
-      height = max_panel_height;
-
-    panel->set_restored_size(gfx::Size(width, height));
-    int x = GetRightMostAvailablePosition() - width;
-    int y = display_area_.bottom() - height;
-
-    // Keep panel visible in the strip even if overlap would occur.
-    // Panel is moved to overflow from the strip after a delay.
-    if (x < display_area_.x()) {
-      x = display_area_.x();
-      panel->set_has_temporary_layout(true);
-      MessageLoop::current()->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&DockedPanelStrip::DelayedMovePanelToOverflow,
-                     base::Unretained(this),
-                     panel),
-          base::TimeDelta::FromMilliseconds(PanelManager::AdjustTimeInterval(
-              kMoveNewPanelToOverflowDelayMs)));
-    }
-    panel->Initialize(gfx::Rect(x, y, width, height));
+    if (height == 0)
+      height = width / kPanelDefaultWidthToHeightRatio;
+    if (width == 0)
+      width = height * kPanelDefaultWidthToHeightRatio;
   }
 
-  // Set panel properties for this strip.
-  panel->SetAppIconVisibility(true);
+  // Constrain sizes to limits.
+  if (width < kPanelMinWidth)
+    width = kPanelMinWidth;
+  else if (width > max_panel_width)
+    width = max_panel_width;
+
+  if (height < kPanelMinHeight)
+    height = kPanelMinHeight;
+  else if (height > max_panel_height)
+    height = max_panel_height;
+
+  panel->set_restored_size(gfx::Size(width, height));
+  int x = GetRightMostAvailablePosition() - width;
+  int y = display_area_.bottom() - height;
+
+  // Keep panel visible in the strip even if overlap would occur.
+  // Panel is moved to overflow from the strip after a delay.
+  if (x < display_area_.x()) {
+    x = display_area_.x();
+    panel->set_has_temporary_layout(true);
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&DockedPanelStrip::DelayedMovePanelToOverflow,
+                   base::Unretained(this),
+                   panel),
+        base::TimeDelta::FromMilliseconds(PanelManager::AdjustTimeInterval(
+            kMoveNewPanelToOverflowDelayMs)));
+  }
+  panel->Initialize(gfx::Rect(x, y, width, height));
 
   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 20 matching lines @@
 
   if (panel->has_temporary_layout()) {
     panels_in_temporary_layout_.erase(panel);
     return;
   }
 
   // Removing an element from the list will invalidate the iterator that refers
   // to it. We need to update the iterator in that case.
   DCHECK(dragging_panel_current_iterator_ == panels_.end() ||
          *dragging_panel_current_iterator_ != panel);
-  bool update_iterator_after_erase =
-      (dragging_panel_original_iterator_ != panels_.end() &&
-       *dragging_panel_original_iterator_ == panel);
 
   // Optimize for the common case of removing the last panel.
   DCHECK(!panels_.empty());
   if (panels_.back() == panel) {
     panels_.pop_back();
-    if (update_iterator_after_erase)
-      dragging_panel_original_iterator_ = panels_.end();
+
+  // Update the saved panel placement if needed. This is because we might remove
+  // |saved_panel_placement_.left_panel_|.
+  // Note: if |left_panel_| moves to overflow and then comes back, it is OK to
+  // restore the panel to the end of list since we do not want to deal with
+  // this case specially.
+  if (saved_panel_placement_.panel &&
+      saved_panel_placement_.left_panel_ == panel)
+    saved_panel_placement_.left_panel_ = NULL;
+
     // No need to refresh layout as the remaining panels are unaffected.
     // Just check if other panels can now fit in the freed up space.
     panel_manager_->MovePanelsOutOfOverflowIfCanFit();
   } else {
     Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
     DCHECK(iter != panels_.end());
     iter = panels_.erase(iter);
-    if (update_iterator_after_erase)
-      dragging_panel_original_iterator_ = iter;
+
+  // Update the saved panel placement if needed. This is because we might remove
+  // |saved_panel_placement_.left_panel_|.
+  if (saved_panel_placement_.panel &&
+      saved_panel_placement_.left_panel_ == panel)
+    saved_panel_placement_.left_panel_ = *iter;
+
     RefreshLayout();
   }
 }
 
 bool DockedPanelStrip::CanShowPanelAsActive(const Panel* panel) const {
   // Panels with temporary layout cannot be shown as active.
   return !panel->has_temporary_layout();
 }
 
+void DockedPanelStrip::SavePanelPlacement(Panel* panel) {
+  DCHECK(!saved_panel_placement_.panel);
+
+  saved_panel_placement_.panel = panel;
+
+  // To recover panel to its original placement, we only need to track the panel
+  // that is placed after it.
+  Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
+  DCHECK(iter != panels_.end());
+  ++iter;
+  saved_panel_placement_.left_panel_ =
+      (iter == panels_.end()) ? NULL : *iter;
+}
+
+void DockedPanelStrip::RestorePanelToSavedPlacement() {
+  DCHECK(saved_panel_placement_.panel);
+
+  Panel* panel = saved_panel_placement_.panel;
+
+  // Find next panel after this panel.
+  Panels::iterator iter = std::find(panels_.begin(), panels_.end(), panel);
+  DCHECK(iter != panels_.end());
+  Panels::iterator next_iter = iter;
+  next_iter++;
+  Panel* next_panel = (next_iter == panels_.end()) ? NULL : *iter;
+
+  // If this panel is already in the right position, nothing to do.

[jennb, 2012/03/08 23:41:09]

nit: rephrase the if-comment to match the if-condition

[jianli, 2012/03/09 21:48:58]

Done.

+  if (next_panel != saved_panel_placement_.left_panel_) {
+    // Remove this panel from its current position.
+    panels_.erase(iter);
+
+    // Insert this panel into its previous position.
+    if (saved_panel_placement_.left_panel_) {
+      Panels::iterator iter_to_insert_before = std::find(panels_.begin(),
+          panels_.end(), saved_panel_placement_.left_panel_);
+      DCHECK(iter_to_insert_before != panels_.end());
+      panels_.insert(iter_to_insert_before, panel);
+    } else {
+      panels_.push_back(panel);
+    }
+  }
+
+  RefreshLayout();
+
+  DiscardSavedPanelPlacement();
+}
+
+void DockedPanelStrip::DiscardSavedPanelPlacement() {
+  DCHECK(saved_panel_placement_.panel);
+  saved_panel_placement_.panel = NULL;

[jennb, 2012/03/08 23:41:09]

Should clear out saved pointer to left_panel too.

[jianli, 2012/03/09 21:48:58]

Done.

+}
+
 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_;
-}
-
-void DockedPanelStrip::StartDraggingPanel(Panel* panel) {
+void DockedPanelStrip::StartDraggingPanelWithinStrip(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_;
 }
 
-void DockedPanelStrip::DragPanel(Panel* panel, int delta_x, int delta_y) {
+void DockedPanelStrip::DragPanelWithinStrip(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);
 
   // Checks and processes other affected panels.
   if (delta_x > 0)
@@ skipping 52 matching lines @@
       break;
 
     // 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;
-        }
-      }
+void DockedPanelStrip::EndDraggingPanelWithinStrip(Panel* panel, bool aborted) {
+  dragging_panel_current_iterator_ = panels_.end();

[jennb, 2012/03/08 23:41:09]

Shame that you lose this iterator right before you might need it again in
RestorePanelToSavedPlacement. Maybe you can copy it to saved panel  placement
for use by the restored code upon cancel?

[jianli, 2012/03/09 21:48:58]

Not sure I understand this comment. I want to separate the logic between
dragging and placement loading/saving. No matter how the dragging is done, the
placement loading/saving will not be affected and might be served for other
purpose.

 
-      // 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;
-      }
-    }
-  }
-
-  dragging_panel_current_iterator_ = dragging_panel_original_iterator_ =
-      panels_.end();
-
-  RefreshLayout();
+  // Calls RefreshLayout to update the dragging panel to its final position
+  // when the drag ends normally. Otherwise, the drag within this strip is
+  // aborted because either the drag enters other strip or the drag is
+  // cancelled. Either way, we don't need to do anything here and let the drag
+  // controller handle the inter-strip transition or the drag cancellation.
+  if (!aborted)
+    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:
       if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
         DecrementMinimizedPanels();
@@ skipping 145 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 && panel == dragging_panel())
+    if (state == Panel::TITLE_ONLY && panel->in_preview_mode())

[jennb, 2012/03/08 23:41:09]

Keep old code here? It's obvious you want to leave title-bar up when dragging a
panel, but not so obvious why preview-mode needs to show the title...

[jianli, 2012/03/09 21:48:58]

Done.

       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 172 matching lines @@
 
   Panels::const_iterator panel_iter = panels_.begin();
   for (; panel_iter != panels_.end(); ++panel_iter) {
     Panel* panel = *panel_iter;
     gfx::Rect new_bounds(panel->GetBounds());
     int x = rightmost_position - new_bounds.width();
 
     if (x < display_area_.x())
       break;
 
-    // Don't update the docked panel that is currently dragged.
-    if (panel != dragging_panel()) {
+    // Don't update the docked panel that is in preview mode.
+    if (!panel->in_preview_mode()) {
       new_bounds.set_x(x);
       new_bounds.set_y(
           GetBottomPositionForExpansionState(panel->expansion_state()) -
               new_bounds.height());
       panel->SetPanelBounds(new_bounds);
     }
 
     rightmost_position = x - kPanelsHorizontalSpacing;
   }
 
   // Add/remove panels from/to overflow. A change in work area or the
   // resize/removal of a panel may affect how many panels fit in the strip.
+  // TODO(jianli): Need to handle the case that panel in preview mode could be

[jennb, 2012/03/08 23:41:09]

crbug this and reference bug # here pls.

[jianli, 2012/03/09 21:48:58]

Done.

+  // moved to overflow.
   if (panel_iter != panels_.end())
     panel_manager_->MovePanelsToOverflow(*panel_iter);
   else
     panel_manager_->MovePanelsOutOfOverflowIfCanFit();
 }
 
 void DockedPanelStrip::DelayedMovePanelToOverflow(Panel* panel) {
   if (panels_in_temporary_layout_.erase(panel)) {
       DCHECK(panel->has_temporary_layout());
       panel_manager_->MovePanelToStrip(panel, PanelStrip::IN_OVERFLOW);
   }
 }
 
 void DockedPanelStrip::CloseAll() {
   // This should only be called at the end of tests to clean up.
   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();
 }