Add PanelOverflowStrip to handle panel overflow.

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/browser/ui/panels/panel_overflow_strip.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.
@@ skipping 41 matching lines @@
   DCHECK_EQ(0, minimized_panel_count_);
 }
 
 void PanelStrip::SetDisplayArea(const gfx::Rect& new_area) {
   if (display_area_ == new_area)
     return;
 
   gfx::Rect old_area = display_area_;
   display_area_ = new_area;
 
-  if (panels_.empty() || new_area.width() == old_area.width())
+  if (panels_.empty())
     return;
 
-  if (new_area.width() < old_area.width())
-    Rearrange();
-  else
-    MovePanelsFromOverflowIfNeeded();
+  Rearrange();
 }
 
 void PanelStrip::AddPanel(Panel* panel) {
   // Always update limits, even for exiting panels, in case the maximums 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));
 
@@ skipping 32 matching lines @@
       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.
+    // TODO(jianli): remove the guard when overflow support is enabled on other
+    // platforms. http://crbug.com/105073
+#if defined(OS_WIN)
     if (x < display_area_.x()) {
       x = display_area_.x();
       int delay_ms = remove_delays_for_testing_ ? 0 :
           kMoveNewPanelToOverflowDelayMilliseconds;
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&PanelStrip::MovePanelToOverflow,
                      base::Unretained(this),
                      panel,
                      true),  // new panel
           delay_ms);
     }
+#endif
     panel->Initialize(gfx::Rect(x, y, width, height));
   }
 
   panels_.push_back(panel);
 }
 
 int PanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
@@ skipping 170 matching lines @@
     panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
 void PanelStrip::OnPanelExpansionStateChanged(
-    Panel::ExpansionState old_state, Panel::ExpansionState new_state) {
-  DCHECK_NE(new_state, old_state);
-  switch (new_state) {
+    Panel* panel, Panel::ExpansionState old_state) {
+  gfx::Size size = panel->restored_size();
+  Panel::ExpansionState expansion_state = panel->expansion_state();
+  switch (expansion_state) {
     case Panel::EXPANDED:
-      DecrementMinimizedPanels();
+      if (old_state == Panel::TITLE_ONLY || old_state == Panel::MINIMIZED)
+        DecrementMinimizedPanels();
+      break;
+    case Panel::TITLE_ONLY:
+      size.set_height(panel->TitleOnlyHeight());
+      if (old_state == Panel::EXPANDED)
+        IncrementMinimizedPanels();
       break;
     case Panel::MINIMIZED:
-    case Panel::TITLE_ONLY:
+      size.set_height(Panel::kMinimizedPanelHeight);
       if (old_state == Panel::EXPANDED)
         IncrementMinimizedPanels();
       break;
     default:
+      NOTREACHED();
       break;
   }
+
+  int bottom = GetBottomPositionForExpansionState(expansion_state);
+  gfx::Rect bounds = panel->GetBounds();
+  panel->SetPanelBounds(
+      gfx::Rect(bounds.right() - size.width(),
+                bottom - size.height(),
+                size.width(),
+                size.height()));
 }
 
 void PanelStrip::IncrementMinimizedPanels() {
   minimized_panel_count_++;
   if (minimized_panel_count_ == 1)
     panel_manager_->mouse_watcher()->AddObserver(this);
   DCHECK_LE(minimized_panel_count_, num_panels());
 }
 
 void PanelStrip::DecrementMinimizedPanels() {
@@ skipping 205 matching lines @@
 
 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();
 
+  // TODO(jianli): remove the guard when overflow support is enabled on other
+  // platforms. http://crbug.com/105073
+#if defined(OS_WIN)
     if (x < display_area_.x()) {
       MovePanelsToOverflow(panel_index);
       break;
     }
+#endif
 
-    new_bounds.set_x(rightmost_position - new_bounds.width());
+    new_bounds.set_x(x);

[jennb, 2011/12/03 00:06:54]

Leave this line the way it was, but move the guard to be above 'int x' line.
That way we only need to remove the guard later and not miss fixing this line.

     new_bounds.set_y(
         GetBottomPositionForExpansionState(panel->expansion_state()) -
             new_bounds.height());
     panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
 
+  // TODO(jianli): remove the guard when overflow support is enabled on other
+  // platforms. http://crbug.com/105073
+#if defined(OS_WIN)
   if (panel_index == panels_.size())
     MovePanelsFromOverflowIfNeeded();
+#endif
 }
 
 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);
+  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);
-  // }
+  PanelOverflowStrip* overflow_strip = panel_manager_->panel_overflow_strip();
+  Panel* overflow_panel;
+  while ((overflow_panel = overflow_strip->first_panel()) &&
+          GetRightMostAvailablePosition() -
+              overflow_panel->restored_size().width() >= display_area_.x()) {
+    overflow_strip->Remove(overflow_panel);
+    AddPanel(overflow_panel);
+  }
 }
 
 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;
 }