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) {
+void DockedPanelStrip::AddPanel(Panel* panel,
+                                PositioningMask positioning_mask) {
   DCHECK_NE(this, panel->panel_strip());
   panel->SetPanelStrip(this);
 
+  bool known_position = (positioning_mask & KNOWN_POSITION) != 0;
+  bool update_bounds = (positioning_mask & DO_NOT_UPDATE_BOUNDS) == 0;
+
+  if (!panel->initialized()) {
+    DCHECK(!known_position && update_bounds);
+    InsertNewlyCreatedPanel(panel);
+  } else if (known_position) {
+    DCHECK(update_bounds);
+    InsertExistingPanelAtKnownPosition(panel);
+  } else {
+    InsertExistingPanelAtDefaultPosition(panel, update_bounds);
+  }
+
   // 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);
+}
+
+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 {
+    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 (panel->has_temporary_layout())
+    panels_in_temporary_layout_.insert(panel);
+  else
+    panels_.push_back(panel);
+}
+
+void DockedPanelStrip::InsertExistingPanelAtKnownPosition(Panel* panel) {
+  DCHECK(panel->initialized());
+
+  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::InsertExistingPanelAtDefaultPosition(
+    Panel* panel, bool update_bounds) {
+  DCHECK(panel->initialized());
+
   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);
 
+  if (update_bounds) {
     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;
         height = Panel::kMinimizedPanelHeight;
       }
       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);
-
-  } 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));
   }
 
-  // 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);
+  panels_.push_back(panel);
 }
 
 int DockedPanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int DockedPanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
 
@@ skipping 15 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;
+
+  // Restoring is only needed when this panel is not in the right position.
+  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;
+  saved_panel_placement_.left_panel = NULL;
+}
+
 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();
 
-      // 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 135 matching lines @@
       panel_manager_->display_settings_provider();
   if (provider->IsAutoHidingDesktopBarEnabled(
           DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM) &&
       provider->GetDesktopBarVisibility(
           DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM) ==
               DisplaySettingsProvider::DESKTOP_BAR_VISIBLE &&
       mouse_y >= display_area_.bottom())
     return true;
 
   // Bring up titlebars if any panel needs the titlebar up.
+  Panel* dragging_panel = dragging_panel_current_iterator_ == panels_.end() ?
+      NULL : *dragging_panel_current_iterator_;
   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 == 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 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
+  // moved to overflow. (http://crbug.com/117574)
   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);
+      panel_manager_->MovePanelToStrip(panel,
+                                       PanelStrip::IN_OVERFLOW,
+                                       PanelStrip::DEFAULT_POSITION);
   }
 }
 
 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();
 }