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 "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.

[Dmitry Titov, 2011/08/05 19:02:20]

We do have notifications today with smaller sizes, especially height. Why to
limit to 100 - that may be a bigger minimal panel then we want. 

As discussed, could you add TODO and ask Ben later?

[jianli, 2011/08/09 19:56:16]

Done.

+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 72 matching lines @@
   const Extension* extension = NULL;
   gfx::Rect bounds = browser->override_bounds();
   while (!ComputeBoundsForNextPanel(&bounds, true)) {
     if (!extension)
       extension = Panel::GetExtension(browser);
     FindAndClosePanelOnOverflow(extension);
   }
 
   Panel* panel = new Panel(browser, bounds);
   panels_.push_back(panel);
+  UpdateMaximumSizeForAllPanels();
 
   return panel;
 }
 
 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::UpdatePreferredSize(Panel* panel,
+                                       const gfx::Size& pref_size) {
+  gfx::Size non_client_size = panel->GetNonClientAreaSize();
+
+  // We need to get and set the restored bounds since the preferred size change
+  // might be triggered when the panel is not expanded.
+  gfx::Rect bounds = panel->GetRestoredBounds();
+
+  // The panel width:
+  // * cannot grow more than the maximum width
+  // * cannot grow to take more than the available horizontal space

[Dmitry Titov, 2011/08/05 19:02:20]

what is exactly 'available horizontal space'? Not clear.

[jianli, 2011/08/09 19:56:16]

Updated comment.

+  // * cannot shrink to be smaller than the initial width
+  int new_panel_width = pref_size.width() + non_client_size.width();
+  if (new_panel_width > max_width_)
+    new_panel_width = max_width_;
+  if (new_panel_width - bounds.width() > current_x_)
+    new_panel_width = bounds.width() + current_x_;
+
+  if (new_panel_width > bounds.width() ||
+      (new_panel_width < bounds.width() &&
+        new_panel_width > panel->initial_size_.width())) {
+    int delta = bounds.width() - new_panel_width;
+    bounds.set_x(bounds.x() + delta);
+    bounds.set_width(new_panel_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 more than the maximum height
+  // * cannot shrink to be smaller than the initial height
+  int new_panel_height = pref_size.height() + non_client_size.height();
+  if (new_panel_height > max_height_)
+    new_panel_height = max_height_;
+
+  if (new_panel_height > bounds.height() ||
+      (new_panel_height < bounds.height() &&
+        new_panel_height > panel->initial_size_.height())) {
+    bounds.set_y(bounds.y() - new_panel_height + bounds.height());
+    bounds.set_height(new_panel_height);
+  }
+
+  panel->SetRestoredBounds(bounds);
+  current_x_ =
+      panels_.back()->GetBounds().x() - kPanelsHorizontalSpacing;
+
+  UpdateMaximumSizeForAllPanels();
+}
+
 bool PanelManager::ShouldBringUpTitleBarForAllMinimizedPanels(
     int mouse_x, int mouse_y) const {
   for (Panels::const_iterator iter = panels_.begin();
        iter != panels_.end(); ++iter) {
     if ((*iter)->ShouldBringUpTitleBar(mouse_x, mouse_y))
       return true;
   }
   return false;
 }
 
@@ skipping 19 matching lines @@
 void PanelManager::Rearrange(Panels::iterator iter_to_start) {
   if (iter_to_start == panels_.end())
     return;
 
   for (Panels::iterator iter = iter_to_start; iter != panels_.end(); ++iter) {
     gfx::Rect new_bounds((*iter)->GetBounds());
     ComputeBoundsForNextPanel(&new_bounds, false);
     if (new_bounds != (*iter)->GetBounds())
       (*iter)->SetPanelBounds(new_bounds);
   }
+
+  UpdateMaximumSizeForAllPanels();
 }
 
 bool PanelManager::ComputeBoundsForNextPanel(gfx::Rect* bounds,
                                              bool allow_size_change) {
   int width = bounds->width();
   int height = bounds->height();
 
   // Update the width and/or height to fit into our constraint.
   if (allow_size_change) {
     if (width == 0 && height == 0) {
@@ skipping 26 matching lines @@
 
 void PanelManager::RemoveAll() {
   // This should not be called when we're in the process of dragging.
   DCHECK(dragging_panel_index_ == kInvalidPanelIndex);
 
   // Start from the bottom to avoid reshuffling.
   for (Panels::reverse_iterator iter = panels_.rbegin();
        iter != panels_.rend(); ++iter)
     (*iter)->Close();
 }
+
+void PanelManager::UpdateMaximumSizeForAllPanels() {
+  for (Panels::const_iterator iter = panels_.begin();
+       iter != panels_.end(); ++iter) {
+    Panel* panel = *iter;
+    int width_can_grow_to = panel->GetBounds().width() + current_x_;

[Dmitry Titov, 2011/08/05 19:02:20]

It is a bit unclear why we give the same area of the screen to all the panels. A
explanatory comment would be nice.

[jianli, 2011/08/09 19:56:16]

Added comment.

+    panel->SetMaximumSize(
+        gfx::Size(std::min(width_can_grow_to, max_width_), max_height_));
+  }
+}