Make panel adjust bounds per preferred size change notification on Windows.

chrome/browser/ui/panels/panel_manager.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_manager.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/window_sizer.h"
 
 namespace {
 // Invalid panel index.
 const size_t kInvalidPanelIndex = static_cast<size_t>(-1);
 
 // Minimum width and height of a panel.
-const int kPanelMinWidthPixels = 64;
-const int kPanelMinHeightPixels = 24;
+// Note: The minimum size of a widget (see widget.cc) is fixed to 100x100.
+// TODO(jianli): Need to fix this to support smaller panel.
+const int kPanelMinWidthPixels = 100;
+const int kPanelMinHeightPixels = 100;
 
 // Default width and height of a panel.
 const int kPanelDefaultWidthPixels = 240;
 const int kPanelDefaultHeightPixels = 290;
 
 // Maxmium width and height of a panel based on the factor of the working
 // area.
 const double kPanelMaxWidthFactor = 1.0;
 const double kPanelMaxHeightFactor = 0.5;
 
@@ skipping 11 matching lines @@
 PanelManager* PanelManager::GetInstance() {
   if (!panel_instance.get())
     panel_instance = new PanelManager();
   return panel_instance.get();
 }
 
 PanelManager::PanelManager()
     : dragging_panel_index_(kInvalidPanelIndex),
       dragging_panel_original_x_(0),
       delayed_titlebar_action_(NO_ACTION),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      auto_sizing_enabled_(true) {
   auto_hiding_desktop_bar_ = AutoHidingDesktopBar::Create(this);
   OnDisplayChanged();
 }
 
 PanelManager::~PanelManager() {
   DCHECK(panels_.empty());
   DCHECK(panels_pending_to_remove_.empty());
 }
 
 void PanelManager::OnDisplayChanged() {
@@ skipping 36 matching lines @@
 Panel* PanelManager::CreatePanel(Browser* browser) {
   // Adjust the width and height to fit into our constraint.
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
 
   if (width == 0 && height == 0) {
     width = kPanelDefaultWidthPixels;
     height = kPanelDefaultHeightPixels;
   }
 
-  int max_panel_width =
-      static_cast<int>(adjusted_work_area_.width() * kPanelMaxWidthFactor);
-  int max_panel_height =
-      static_cast<int>(adjusted_work_area_.height() * kPanelMaxHeightFactor);
+  int max_panel_width = GetMaxPanelWidth();
+  int max_panel_height = GetMaxPanelHeight();
 
   if (width < kPanelMinWidthPixels)
     width = kPanelMinWidthPixels;
   else if (width > max_panel_width)
     width = max_panel_width;
 
   if (height < kPanelMinHeightPixels)
     height = kPanelMinHeightPixels;
   else if (height > max_panel_height)
     height = max_panel_height;
 
   // Compute the origin. Ensure that it falls within the adjusted work area by
   // closing other panels if needed.
   int y = adjusted_work_area_.bottom() - height;
 
   const Extension* extension = NULL;
   int x;
   while ((x = GetRightMostAvaialblePosition() - width) <
          adjusted_work_area_.x() ) {
     if (!extension)
       extension = Panel::GetExtension(browser);
     FindAndClosePanelOnOverflow(extension);
   }
 
   // Now create the panel with the computed bounds.
   Panel* panel = new Panel(browser, gfx::Rect(x, y, width, height));
   panels_.push_back(panel);
 
+  UpdateMaxSizeForAllPanels();
+
   return panel;
 }
 
+int PanelManager::GetMaxPanelWidth() const {
+  return static_cast<int>(adjusted_work_area_.width() * kPanelMaxWidthFactor);
+}
+
+int PanelManager::GetMaxPanelHeight() const {
+  return static_cast<int>(adjusted_work_area_.height() * kPanelMaxHeightFactor);
+}
+
 int PanelManager::GetRightMostAvaialblePosition() const {
   return panels_.empty() ? adjusted_work_area_.right() :
       (panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing);
 }
 
 void PanelManager::Remove(Panel* panel) {
   // If we're in the process of dragging, delay the removal.
   if (dragging_panel_index_ != kInvalidPanelIndex) {
     panels_pending_to_remove_.push_back(panel);
     return;
@@ skipping 141 matching lines @@
   } else {
     panels_[dragging_panel_index_]->SetPanelBounds(
         dragging_panel_bounds_);
   }
 
   dragging_panel_index_ = kInvalidPanelIndex;
 
   DelayedRemove();
 }
 
+void PanelManager::OnPreferredWindowSizeChanged(
+    Panel* panel, const gfx::Size& preferred_window_size) {
+  if (!auto_sizing_enabled_)
+    return;
+
+  gfx::Rect bounds = panel->GetBounds();
+  int restored_height = panel->GetRestoredHeight();
+
+  // The panel width:
+  // * cannot grow or shrink to go beyond [min_width, max_width]
+  // * cannot grow to take more than the available space and go beyond the left
+  //   of the work area.
+  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();
+
+  int right_most_available_position = GetRightMostAvaialblePosition();
+  if (new_width - bounds.width() > right_most_available_position)
+    new_width = bounds.width() + right_most_available_position;
+
+  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();
+
+  if (new_height != restored_height) {
+    // If the panel is not expanded, we only need to save the new restored
+    // height.
+    if (panel->expansion_state() == Panel::EXPANDED) {
+      bounds.set_y(bounds.y() - new_height + bounds.height());
+      bounds.set_height(new_height);
+    } else {
+      panel->SetRestoredHeight(new_height);
+    }
+  }
+
+  panel->SetPanelBounds(bounds);
+
+  UpdateMaxSizeForAllPanels();
+}
+
 bool PanelManager::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.
   if (auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM) &&
       auto_hiding_desktop_bar_->GetVisibility(
               AutoHidingDesktopBar::ALIGN_BOTTOM) ==
           AutoHidingDesktopBar::VISIBLE &&
       mouse_y >= adjusted_work_area_.bottom())
     return true;
 
@@ skipping 87 matching lines @@
 int PanelManager::GetBottomPositionForExpansionState(
     Panel::ExpansionState expansion_state) const {
   // If there is an auto-hiding desktop bar aligned to the bottom edge, we need
   // to move the minimize panel down to the bottom edge.
   int bottom = adjusted_work_area_.bottom();
   if (expansion_state == Panel::MINIMIZED &&
       auto_hiding_desktop_bar_->IsEnabled(AutoHidingDesktopBar::ALIGN_BOTTOM)) {
     bottom += auto_hiding_desktop_bar_->GetThickness(
         AutoHidingDesktopBar::ALIGN_BOTTOM);
   }
+
   return bottom;
 }
 
 void PanelManager::OnAutoHidingDesktopBarThicknessChanged() {
   AdjustWorkAreaForAutoHidingDesktopBars();
   Rearrange(panels_.begin(), adjusted_work_area_.right());
 }
 
 void PanelManager::OnAutoHidingDesktopBarVisibilityChanged(
     AutoHidingDesktopBar::Alignment alignment,
@@ skipping 20 matching lines @@
     Panel* panel = *iter;
 
     gfx::Rect new_bounds(panel->GetBounds());
     new_bounds.set_x(rightmost_position - new_bounds.width());
     new_bounds.set_y(adjusted_work_area_.bottom() - new_bounds.height());
     if (new_bounds != panel->GetBounds())
       panel->SetPanelBounds(new_bounds);
 
     rightmost_position = new_bounds.x() - kPanelsHorizontalSpacing;
   }
+
+  UpdateMaxSizeForAllPanels();
 }
 
 void PanelManager::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 PanelManager::is_dragging_panel() const {
   return dragging_panel_index_ != kInvalidPanelIndex;
 }
+
+void PanelManager::UpdateMaxSizeForAllPanels() {
+  if (!auto_sizing_enabled_)
+    return;
+
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    Panel* panel = *iter;
+    // A panel can at most grow to take over all the avaialble space that is
+    // returned by GetRightMostAvaialblePosition.
+    int width_can_grow_to =
+        panel->GetBounds().width() + GetRightMostAvaialblePosition();
+    panel->SetMaxSize(gfx::Size(
+        std::min(width_can_grow_to, GetMaxPanelWidth()),
+        GetMaxPanelHeight()));
+  }
+}