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 area) {
+  if (display_area_ == area)
     return;
 
-  strip_bounds_ = bounds;
-  Rearrange(panels_.begin(), StartingRightPosition());
+  // Check for overflow.
+  if (!panels_.empty() && area.width() < display_area_.width()) {

[jianli, 2011/12/01 21:36:28]

Probably better to set new area 1st so that all later rearrangement are based on
this. Like:
  gfx::Rect old_area = display_area_;
  display_area_ = new_area;

  // Nothing to do if no panel.
  if (panels_.empty())
    return;

  if (new_area.width() < old_area.width()) {
    // Might need to move panels to overflow area if the display area is shrunk.
    ...
  } else {
    // Might need to move overflows to normal display if the
display area is enlarged.
    ...
  }

+    int min_x = display_area_.right() - area.width();

[jianli, 2011/12/01 21:36:28]

display_area_.right() => area.right()
It might be the case that display_area_.right() is not same as area.right() due
to taskbar being aligned to the left screen edge.

In addition, do we want to move overflow panels to the normal strip if the
display area is enlarged?

+    while (panels_.back()->GetBounds().x() < min_x) {
+      MovePanelToOverflow(panels_.back(), false);
+      DCHECK(!panels_.empty());  // At least one panel must fit!

[jianli, 2011/12/01 21:36:28]

This might not be always true if the display area has been shrunk a lot by more
than 2/3 and the 1st panel occupies 1/3 of the original area.

+    }
+  }
+
+  display_area_ = area;
+  Rearrange();
 }
 
 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(),
+                   base::Unretained(panel), true),  // new panel

[jianli, 2011/12/01 21:36:28]

There could be a case that the new panel is being closed immediately by the
script, though very rarely.

[jennb, 2011/12/01 23:10:17]

When the delayed method is called, it checks whether the panel is actually in
the strip before doing anything.

+        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);
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PANEL_REMOVED,
+      content::Source<Panel>(panel),
+      content::NotificationService::NoDetails());
+
+  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);
+
+    // Reposition all the panels to the left.

[jianli, 2011/12/01 21:36:28]

I think this logic could be folded into Rearrange method that will move the
unfit panels to the overflow area automatically.

+    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;

[jianli, 2011/12/01 21:36:28]

extra space after for.

+          --i) {
+      Panel* this_panel = panels_[i];
+      gfx::Rect this_bounds = this_panel->GetBounds();
+      int shifted_x = this_bounds.x() + delta_x;
+      if (delta_x < 0 && shifted_x < display_area_.x()) {
+        MovePanelToOverflow(this_panel, false);  // safe to erase from end
+      } else {
+        this_bounds.set_x(shifted_x);
+        this_panel->SetPanelBounds(this_bounds);
+      }
+    }
+
+    // Finally, check if size change caused current panel to overflow.
+    if (bounds.x() < display_area_.x()) {
+      MovePanelToOverflow(panel, false);
+      return;
+    }
+  }
 
   panel->SetPanelBounds(bounds);
+
+  // Try to add more panels to the strip if size decreased.
+  if (delta_x > 0)
+    AddPanelsFromOverflow();
 }
 
 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) {
+void PanelStrip::Rearrange() {
+  int rightmost_position = StartingRightPosition();
+  for (Panels::iterator iter = panels_.begin(); iter != panels_.end(); ++iter) {
     Panel* panel = *iter;
     gfx::Rect new_bounds(panel->GetBounds());
     new_bounds.set_x(rightmost_position - new_bounds.width());
     new_bounds.set_y(
         GetBottomPositionForExpansionState(panel->expansion_state()) -
             new_bounds.height());
+    DCHECK(new_bounds.x() >= display_area_.x());  // Should not overflow.
     panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
+
+  AddPanelsFromOverflow();  // Maybe there's more room now...
+}
+
+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::AddPanelsFromOverflow() {
+  // 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);
+  //   AddExistingPanel(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;
 }