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 99 matching lines @@
   else if (height > max_panel_height)
     height = max_panel_height;
   panel->set_restored_size(gfx::Size(width, height));
 
   // Layout the new panel.
   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.
+  // TODO(jianli): Enable overflow area support for other platforms.

[jennb, 2011/12/02 19:15:00]

Could you file a bug and put bug # here so we don't lose track of this TODO?

[jianli, 2011/12/02 23:23:46]

Done.

+#if defined(OS_WIN)
   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);
+        remove_delays_for_testing_ ?
+            0 : kMoveNewPanelToOverflowDelayMilliseconds);
   }
+#endif
   panel->Initialize(gfx::Rect(x, y, width, height));
 }
 
 void PanelStrip::AddExistingPanel(Panel* panel) {
+  DCHECK(panel->expansion_state() == Panel::IN_OVERFLOW);
+
   gfx::Size restored_size = panel->restored_size();
   int height = restored_size.height();
   int width = restored_size.width();
   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));
+  panel->SetExpansionState(Panel::EXPANDED);
 }
 
 int PanelStrip::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelStrip::GetMaxPanelHeight() const {
   return display_area_.height();
 }
 
@@ skipping 30 matching lines @@
 
 bool PanelStrip::DoRemove(Panel* panel) {
   Panels::iterator iter = find(panels_.begin(), panels_.end(), panel);
   if (iter == panels_.end())
     return false;
 
   if (panel->expansion_state() != Panel::EXPANDED)
     DecrementMinimizedPanels();
 
   panels_.erase(iter);
+  panel_manager_->OnPanelRemoved(panel);
   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 115 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) {
+  DCHECK(panel->expansion_state() != Panel::IN_OVERFLOW);
+
+  gfx::Size size = panel->restored_size();

[jennb, 2011/12/02 19:15:00]

Should only have to modify height. Panels coming from overflow already had their
bounds corrected in AddPanel, which is called before this method.

[jianli, 2011/12/02 23:23:46]

I rather update both width and height since this trivial additional overhead
will guarantee we will pick up the restored size under any kind of circumstance.

+  switch (panel->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();

[jennb, 2011/12/02 19:15:00]

nit: Don't need DCHECK up above when we have this NOTREACHED here.

[jianli, 2011/12/02 23:23:46]

Done.

       break;
   }
+
+  int bottom = GetBottomPositionForExpansionState(panel->expansion_state());

[jennb, 2011/12/02 19:15:00]

nit: Use a local var for panel->expansion_state() as you use it here and in the
switch.

[jianli, 2011/12/02 23:23:46]

Done.

+  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 191 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() {

[jennb, 2011/12/02 21:16:58]

Need to #if windows the overflow logic here too to keep mac/linux behavior the
same.

[jianli, 2011/12/02 23:23:46]

Done.

   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);
@@ skipping 17 matching lines @@
   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;
 }