Add panel overflow logic to panel strip.

chrome/browser/ui/panels/panel_strip.cc

 // Copyright (c) 2011 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/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/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 {
 // Invalid panel index.
 const size_t kInvalidPanelIndex = static_cast<size_t>(-1);
 
 // 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
 
 // Maxmium width of a panel is based on a factor of the entire panel strip.
 const double kPanelMaxWidthFactor = 0.35;
 
+// New panels that cannot fit in the panel strip are moved to overflow
+// after a brief delay.
+const int kMoveNewPanelToOverflowDelayMilliseconds = 1500;  // arbitrary
+
 // Occasionally some system, like Windows, might not bring up or down the bottom
 // bar when the mouse enters or leaves the bottom screen area. This is the
 // maximum time we will wait for the bottom bar visibility change notification.
 // After the time expires, we bring up/down the titlebars as planned.
 const int kMaxMillisecondsWaitForBottomBarVisibilityChange = 1000;
 
 // See usage below.
 #if defined(TOOLKIT_GTK)
 const int kMillisecondsBeforeCollapsingFromTitleOnlyState = 2000;
 #else
 const int kMillisecondsBeforeCollapsingFromTitleOnlyState = 0;
 #endif
 }  // namespace
 
 // static
 const int PanelStrip::kPanelMinWidth = 100;
 const int PanelStrip::kPanelMinHeight = 20;
 
 PanelStrip::PanelStrip(PanelManager* panel_manager)
     : panel_manager_(panel_manager),
       minimized_panel_count_(0),
       are_titlebars_up_(false),
       dragging_panel_index_(kInvalidPanelIndex),
       dragging_panel_original_x_(0),
       delayed_titlebar_action_(NO_ACTION),
       remove_delays_for_testing_(false),
-      titlebar_action_factory_(this) {
+      titlebar_action_factory_(this),
+      overflow_action_factory_(this) {
 }
 
 PanelStrip::~PanelStrip() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
   DCHECK_EQ(0, minimized_panel_count_);
 }
 
-void PanelStrip::SetBounds(const gfx::Rect bounds) {
-  if (strip_bounds_ == bounds)
+void PanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
+  if (display_area_ == new_area)
     return;
 
-  strip_bounds_ = bounds;
-  Rearrange(panels_.begin(), StartingRightPosition());
+  gfx::Rect old_area = display_area_;
+  display_area_ = new_area;
+
+  if (panels_.empty() || new_area.width() == old_area.width())
+    return;
+
+  if (new_area.width() < old_area.width())
+    Rearrange();
+  else
+    MovePanelsFromOverflowIfNeeded();
 }
 
 void PanelStrip::AddPanel(Panel* panel) {
   if (panel->initialized())
     AddExistingPanel(panel);
   else
     AddNewPanel(panel);
   panels_.push_back(panel);
 }
 
@@ skipping 25 matching lines @@
   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));
 
   // Layout the new panel.
-  int y = strip_bounds_.bottom() - height;
+  int y = display_area_.bottom() - height;
   int x = GetRightMostAvailablePosition() - width;
+
+  // 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();
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&PanelStrip::MovePanelToOverflow,
+                   overflow_action_factory_.GetWeakPtr(),
+                   panel,
+                   true),  // new panel
+        kMoveNewPanelToOverflowDelayMilliseconds);
+  }
   panel->Initialize(gfx::Rect(x, y, width, height));
 }
 
 void PanelStrip::AddExistingPanel(Panel* panel) {
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
-  int x = GetRightMostAvailablePosition() - width;
-  int y = strip_bounds_.bottom() - height;
+  int x;
+  while ((x = GetRightMostAvailablePosition() - width) < display_area_.x()) {
+    DCHECK(!panels_.empty());
+    MovePanelToOverflow(panels_.back(), false);
+  }
+  int y = display_area_.bottom() - height;
   panel->SetPanelBounds(gfx::Rect(x, y, width, height));
 }
 
 int PanelStrip::GetMaxPanelWidth() const {
-  return static_cast<int>(strip_bounds_.width() * kPanelMaxWidthFactor);
+  return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelStrip::GetMaxPanelHeight() const {
-  return strip_bounds_.height();
+  return display_area_.height();
 }
 
 int PanelStrip::StartingRightPosition() const {
-  return strip_bounds_.right();
+  return display_area_.right();
 }
 
 int PanelStrip::GetRightMostAvailablePosition() const {
   return panels_.empty() ? StartingRightPosition() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
 bool PanelStrip::Remove(Panel* panel) {
   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_index_ != kInvalidPanelIndex) {
     panels_pending_to_remove_.push_back(panel);
     return true;
   }
 
   DoRemove(panel);
+  Rearrange();
   return true;
 }
 
 void PanelStrip::DelayedRemove() {
   for (size_t i = 0; i < panels_pending_to_remove_.size(); ++i)
     DoRemove(panels_pending_to_remove_[i]);
   panels_pending_to_remove_.clear();
+  Rearrange();
 }
 
-void PanelStrip::DoRemove(Panel* panel) {
+bool PanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
-    return;
+    return false;
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
-  gfx::Rect bounds = (*iter)->GetBounds();
-  Rearrange(panels_.erase(iter), bounds.right());
-  panel_manager_->OnPanelRemoved(panel);
+  panels_.erase(iter);
+  return true;
 }
 
 void PanelStrip::StartDragging(Panel* panel) {
   for (size_t i = 0; i < panels_.size(); ++i) {
     if (panels_[i] == panel) {
       dragging_panel_index_ = i;
       dragging_panel_bounds_ = panel->GetBounds();
       dragging_panel_original_x_ = dragging_panel_bounds_.x();
       break;
     }
@@ skipping 156 matching lines @@
   gfx::Rect bounds = panel->GetBounds();
 
   // The panel width:
   // * cannot grow or shrink to go beyond [min_width, max_width]
   int new_width = preferred_window_size.width();
   if (new_width > panel->max_size().width())
     new_width = panel->max_size().width();
   if (new_width < panel->min_size().width())
     new_width = panel->min_size().width();
 
-  if (new_width != bounds.width()) {
-    int delta = bounds.width() - new_width;
-    bounds.set_x(bounds.x() + delta);
-    bounds.set_width(new_width);
-
-    // Reposition all the panels on the left.
-    int panel_index = -1;
-    for (int i = 0; i < static_cast<int>(panels_.size()); ++i) {
-      if (panels_[i] == panel) {
-        panel_index = i;
-        break;
-      }
-    }
-    DCHECK(panel_index >= 0);
-    for (int i = static_cast<int>(panels_.size()) -1; i > panel_index;
-         --i) {
-      gfx::Rect this_bounds = panels_[i]->GetBounds();
-      this_bounds.set_x(this_bounds.x() + delta);
-      panels_[i]->SetPanelBounds(this_bounds);
-    }
-  }
-
   // The panel height:
   // * cannot grow or shrink to go beyond [min_height, max_height]
   int new_height = preferred_window_size.height();
   if (new_height > panel->max_size().height())
     new_height = panel->max_size().height();
   if (new_height < panel->min_size().height())
     new_height = panel->min_size().height();
 
+  // Update restored size.
+  gfx::Size new_size(new_width, new_height);
+  if (new_size != panel->restored_size())
+    panel->set_restored_size(preferred_window_size);
+
   // Only need to adjust bounds height when panel is expanded.
-  gfx::Size restored_size = panel->restored_size();
-  if (new_height != restored_size.height() &&
+  if (new_height != bounds.height() &&
       panel->expansion_state() == Panel::EXPANDED) {
-    bounds.set_y(bounds.y() - new_height + bounds.height());
+    bounds.set_y(bounds.bottom() - new_height);
     bounds.set_height(new_height);
   }
 
-  gfx::Size new_size = gfx::Size(new_width, new_height);
-  if (new_size != restored_size)
-    panel->set_restored_size(new_size);
+  // Adjust bounds width.
+  int delta_x = bounds.width() - new_width;
+  if (delta_x != 0) {
+    bounds.set_width(new_width);
+    bounds.set_x(bounds.x() + delta_x);
+  }
 
   panel->SetPanelBounds(bounds);
+
+  // Only need to rearrange if panel's width changed.
+  if (delta_x != 0)
+    Rearrange();
 }
 
 bool PanelStrip::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   // We should always bring up the titlebar if the mouse is over the
   // visible auto-hiding bottom bar.
   AutoHidingDesktopBar* desktop_bar = panel_manager_->auto_hiding_desktop_bar();
   if (desktop_bar->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM) &&
       desktop_bar->GetVisibility(AutoHidingDesktopBar::ALIGN_BOTTOM) ==
           AutoHidingDesktopBar::VISIBLE &&
-      mouse_y >= strip_bounds_.bottom())
+      mouse_y >= display_area_.bottom())
     return true;
 
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     if ((*iter)->ShouldBringUpTitlebar(mouse_x, mouse_y))
       return true;
   }
   return false;
 }
 
@@ skipping 87 matching lines @@
         panel->SetExpansionState(Panel::TITLE_ONLY);
     } else {
       if (panel->expansion_state() == Panel::TITLE_ONLY)
         panel->SetExpansionState(Panel::MINIMIZED);
     }
   }
 }
 
 int PanelStrip::GetBottomPositionForExpansionState(
     Panel::ExpansionState expansion_state) const {
-  int bottom = strip_bounds_.bottom();
+  int bottom = display_area_.bottom();
   // If there is an auto-hiding desktop bar aligned to the bottom edge, we need
   // to move the title-only panel above the auto-hiding desktop bar.
   AutoHidingDesktopBar* desktop_bar = panel_manager_->auto_hiding_desktop_bar();
   if (expansion_state == Panel::TITLE_ONLY &&
       desktop_bar->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM)) {
     bottom -= desktop_bar->GetThickness(AutoHidingDesktopBar::ALIGN_BOTTOM);
   }
 
   return bottom;
 }
@@ skipping 13 matching lines @@
   AutoHidingDesktopBar::Visibility expected_visibility =
       delayed_titlebar_action_ == BRING_UP ? AutoHidingDesktopBar::VISIBLE
                                            : AutoHidingDesktopBar::HIDDEN;
   if (visibility != expected_visibility)
     return;
 
   DoBringUpOrDownTitlebars(delayed_titlebar_action_ == BRING_UP);
   delayed_titlebar_action_ = NO_ACTION;
 }
 
-void PanelStrip::Rearrange(Panels::iterator iter_to_start,
-                           int rightmost_position) {
-  for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
-    Panel* panel = *iter;
+void PanelStrip::Rearrange() {
+  int rightmost_position = StartingRightPosition();
+
+  size_t panel_index = 0;
+  for (; panel_index < panels_.size(); ++panel_index) {
+    Panel* panel = panels_[panel_index];
     gfx::Rect new_bounds(panel->GetBounds());
+    int x = rightmost_position - new_bounds.width();
+
+    if (x < display_area_.x()) {
+      MovePanelsToOverflow(panel_index);
+      break;
+    }
+
     new_bounds.set_x(rightmost_position - new_bounds.width());
     new_bounds.set_y(
         GetBottomPositionForExpansionState(panel->expansion_state()) -
             new_bounds.height());
     panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
+
+  if (panel_index == panels_.size())
+    MovePanelsFromOverflowIfNeeded();
+}
+
+void PanelStrip::MovePanelsToOverflow(size_t overflow_point) {
+  DCHECK(overflow_point >= 0);
+  // Move panels in reverse to maintain their order.
+  for (size_t i = panels_.size() - 1; i >= overflow_point; --i)
+    MovePanelToOverflow(panels_[i], false);
+}
+
+void PanelStrip::MovePanelToOverflow(Panel* panel, bool is_new) {
+  if (!DoRemove(panel))
+    return;
+
+  // TODO(jianli): Replace with the real code using overflow strip.
+  // panel_manager_->panel_overflow_strip()->AddPanel(panel, is_new);
+}
+
+void PanelStrip::MovePanelsFromOverflowIfNeeded() {
+  // TODO(jianli): Replace with the real code using overflow strip.
+  // PanelOverflowStrip* overflow = panel_manager_->panel_overflow_strip();
+  // Panel* candidate;
+  // while (candidate = overflow->FirstPanel() &&
+  //     GetRightMostAvailablePosition -
+  //         candidate->GetRestoredSize().width() >= display_area_.x()) {
+  //   overflow->Remove(candidate);
+  //   AddPanel(candidate);
+  // }
 }
 
 void PanelStrip::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // 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 PanelStrip::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }