Add overflow indicator count on Windows.

chrome/browser/ui/panels/panel_overflow_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_overflow_strip.h"
 
 #include "base/logging.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_indicator.h"
 #include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_service.h"
 #include "ui/base/animation/slide_animation.h"
 
 namespace {
 // The width of the overflow area that is expanded to show more info, i.e.
 // titles, when the mouse hovers over the area.
 static const int kOverflowAreaHoverWidth = 200;
 
-// Maximium number of overflow panels allowed to be shown.
-const size_t kMaxVisibleOverflowPanelsAllowed = 6;
+// Maximium number of visible overflow panels when the overflow area is shrunk.

[jennb, 2011/12/20 02:08:23]

Still using shrunk?

[jianli, 2011/12/20 22:08:10]

Done.

+const size_t kMaxVisibleOverflowPanelsOnShrunk = 6;
+
+// Height to display-area ratio that maximium number of visible overflow panels

[jennb, 2011/12/20 02:08:23]

Lumpy sentence. Phrasing it like the comment you wrote in the Update method for
this will improve it.

[jianli, 2011/12/20 22:08:10]

Done.

+// cannot occupy more than when the mouse hovers over the overflow area.
+const double kHeightRatioForMaxVisibleOverflowPanelsOnHover = 0.67;
 
 // This value is experimental and subjective.
 const int kOverflowHoverAnimationMs = 180;
 }
 
 PanelOverflowStrip::PanelOverflowStrip(PanelManager* panel_manager)
     : panel_manager_(panel_manager),
       current_display_width_(0),
-      max_visible_panels_(kMaxVisibleOverflowPanelsAllowed),
+      max_visible_panels_(kMaxVisibleOverflowPanelsOnShrunk),
+      max_visible_panels_on_hover_(0),
       are_overflow_titles_shown_(false),
       overflow_hover_animator_start_width_(0),
       overflow_hover_animator_end_width_(0) {
+  registrar_.Add(this, content::NOTIFICATION_APP_TERMINATING,

[jennb, 2011/12/20 02:08:23]

Comment here about why we register for this.

[jianli, 2011/12/20 22:08:10]

Not needed since we do not need observer now.

+                 content::NotificationService::AllSources());
 }
 
 PanelOverflowStrip::~PanelOverflowStrip() {
   DCHECK(panels_.empty());
+  DCHECK(!overflow_indicator_.get());
 }
 
 void PanelOverflowStrip::SetDisplayArea(const gfx::Rect& display_area) {
   if (display_area_ == display_area)
     return;
+  display_area_ = display_area;
 
-  display_area_ = display_area;
+  UpdateMaxVisibkePanelsOnHover();
   UpdateCurrentWidth();
 
   Refresh();
 }
 
+void PanelOverflowStrip::UpdateMaxVisibkePanelsOnHover() {
+  // The maximum number of visible overflow panels cannot occupy more than
+  // certain percentage of the display area height.
+  // Note that we need to delay the computation of this value if no overflow
+  // panel is added.
+  if (panels_.empty()) {
+    max_visible_panels_on_hover_ = 0;
+  } else if (!max_visible_panels_on_hover_) {
+    max_visible_panels_on_hover_ =
+        kHeightRatioForMaxVisibleOverflowPanelsOnHover *
+        display_area_.height() /
+        panels_.front()->IconOnlySize().height();
+  }
+}
+
 void PanelOverflowStrip::UpdateCurrentWidth() {
   current_display_width_ = are_overflow_titles_shown_ ? kOverflowAreaHoverWidth
                                                       : display_area_.width();
 }
 
 void PanelOverflowStrip::AddPanel(Panel* panel) {
   // TODO(jianli): consider using other container to improve the perf for
   // inserting to the front. http://crbug.com/106222
   DCHECK_EQ(Panel::IN_OVERFLOW, panel->expansion_state());
   // Newly created panels that were temporarily in the panel strip
   // are added to the back of the overflow, whereas panels that are
   // bumped from the panel strip by other panels go to the front
   // of overflow.
   if (panel->has_temporary_layout()) {
     panel->set_has_temporary_layout(false);
     panels_.push_back(panel);
     DoRefresh(panels_.size() - 1, panels_.size() - 1);
   } else {
     panels_.insert(panels_.begin(), panel);
     Refresh();
   }
 
   if (panels_.size() == 1)
     panel_manager_->mouse_watcher()->AddObserver(this);
+
+  UpdateOverflowIndicator(current_display_width_);
 }
 
 bool PanelOverflowStrip::Remove(Panel* panel) {
   size_t index = 0;
   for (Panels::iterator iter = panels_.begin(); iter != panels_.end();
        ++iter, ++index) {
     if (*iter == panel) {
       panels_.erase(iter);
       DoRefresh(index, panels_.size() - 1);
       panel_manager_->OnPanelRemoved(panel);
-      if (panels_.empty())
+      if (panels_.empty()) {
         panel_manager_->mouse_watcher()->RemoveObserver(this);
+        overflow_indicator_.reset();

[jennb, 2011/12/20 02:08:23]

Seems odd to reset the indicator only to recreate it again in line 115. Maybe
the indicator should not exist if overflow panels do not exceed
max_visible_overflow_panels_?

[jianli, 2011/12/20 22:08:10]

Changed to create the overflow indicator on a as-needed basis.

+      }
+      UpdateOverflowIndicator(current_display_width_);
       return true;
     }
   }
   return false;
 }
 
 void PanelOverflowStrip::RemoveAll() {
   // 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();
 }
 
 void PanelOverflowStrip::OnPanelExpansionStateChanged(
     Panel* panel, Panel::ExpansionState old_state) {
   DCHECK(panel->expansion_state() == Panel::IN_OVERFLOW);
   panel_manager_->panel_strip()->Remove(panel);
   AddPanel(panel);
   panel->SetAppIconVisibility(false);
   panel->set_draggable(false);
 }
 
+void PanelOverflowStrip::OnPanelAttentionStateChanged(Panel* panel) {
+  DCHECK(panel->expansion_state() == Panel::IN_OVERFLOW);
+  UpdateOverflowIndicator(current_display_width_);
+}
+
 void PanelOverflowStrip::Refresh() {
   if (panels_.empty())
     return;
   DoRefresh(0, panels_.size() - 1);
 }
 
 void PanelOverflowStrip::DoRefresh(size_t start_index, size_t end_index) {
   if (panels_.empty() || start_index == panels_.size())
     return;
 
   DCHECK(end_index < panels_.size());
 
   for (size_t index = start_index; index <= end_index; ++index) {
     Panel* panel = panels_[index];
     gfx::Rect new_bounds = ComputeLayout(index,
                                          panel->IconOnlySize());
     panel->SetPanelBounds(new_bounds);
   }
 }
 
+void PanelOverflowStrip::UpdateOverflowIndicator(int width) {
+  if (!overflow_indicator_.get())
+    overflow_indicator_.reset(PanelOverflowIndicator::Create());
+
+  UpdateMaxVisibkePanelsOnHover();

[jennb, 2011/12/20 02:08:23]

Shouldn't need to recompute this every time a panel is added/removed from
overflow. The max should be unchanged as long as display area does not change.

[jianli, 2011/12/20 22:08:10]

Updated. When display area is changed, we might not be able to compute this max
value because no overflow panel is added yet and the max value is computed based
on the overflow panel's height.

+  int max_visible_panels = width > display_area_.width() ?
+      max_visible_panels_on_hover_ : max_visible_panels_;
+
+  // Setting the count to 0 will hide the indicator.
+  if (num_panels() <= max_visible_panels) {
+    overflow_indicator_->SetCount(0);
+    return;
+  }
+
+  // Update the bounds and count.
+  int height = overflow_indicator_->GetHeight();
+  overflow_indicator_->SetBounds(gfx::Rect(
+      display_area_.x(),
+      panels_[max_visible_panels - 1]->GetBounds().y() - height,
+      width,
+      height));
+  overflow_indicator_->SetCount(num_panels() - max_visible_panels);
+
+  // The overflow indicator is painted as drawing attention only when there is
+  // at least one hidden panel that is drawing attention.
+  bool is_drawing_attention = false;
+  for (int index = max_visible_panels; index < num_panels(); ++index) {
+    if (panels_[index]->IsDrawingAttention())
+      is_drawing_attention = true;

[jennb, 2011/12/20 02:08:23]

break out of loop as soon as you find one drawing attention

[jianli, 2011/12/20 22:08:10]

Done.

+  }
+  if (is_drawing_attention)
+    overflow_indicator_->DrawAttention();
+  else
+    overflow_indicator_->StopDrawingAttention();
+}
+
 gfx::Rect PanelOverflowStrip::ComputeLayout(
     size_t index, const gfx::Size& iconified_size) const {
   DCHECK(index != kInvalidPanelIndex);
 
   gfx::Rect bounds;
   int bottom = (index == 0) ? display_area_.bottom() :
       panels_[index - 1]->GetBounds().y();
   bounds.set_x(display_area_.x());
   bounds.set_y(bottom - iconified_size.height());
 
-  if (are_overflow_titles_shown_ ||
-      static_cast<int>(index) < max_visible_panels_) {
+  if (static_cast<int>(index) < max_visible_panels()) {
     bounds.set_width(current_display_width_);
     bounds.set_height(iconified_size.height());
   } else {
     // Invisible for overflow-on-overflow.
     bounds.set_width(0);
     bounds.set_height(0);
   }
 
   return bounds;
 }
 
 void PanelOverflowStrip::OnMouseMove(const gfx::Point& mouse_position) {
   bool show_overflow_titles = ShouldShowOverflowTitles(mouse_position);
   ShowOverflowTitles(show_overflow_titles);
 }
 
 bool PanelOverflowStrip::ShouldShowOverflowTitles(
     const gfx::Point& mouse_position) const {
   if (panels_.empty())
     return false;
 
-  Panel* top_visible_panel;
-  if (are_overflow_titles_shown_) {
-    top_visible_panel = panels_.back();
-  } else {
-    top_visible_panel = num_panels() >= max_visible_panels_ ?
-        panels_[max_visible_panels_ - 1] : panels_.back();
-  }
+  Panel* top_visible_panel = num_panels() >= max_visible_panels() ?
+        panels_[max_visible_panels() - 1] : panels_.back();
   return mouse_position.x() <= display_area_.x() + current_display_width_ &&
          top_visible_panel->GetBounds().y() <= mouse_position.y() &&
          mouse_position.y() <= display_area_.bottom();
 }
 
 void PanelOverflowStrip::ShowOverflowTitles(bool show_overflow_titles) {
   if (show_overflow_titles == are_overflow_titles_shown_)
     return;
   are_overflow_titles_shown_ = show_overflow_titles;
 
@@ skipping 31 matching lines @@
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
       content::Source<PanelOverflowStrip>(this),
       content::NotificationService::NoDetails());
 }
 
 void PanelOverflowStrip::AnimationProgressed(const ui::Animation* animation) {
   int current_display_width = overflow_hover_animator_->CurrentValueBetween(
       overflow_hover_animator_start_width_, overflow_hover_animator_end_width_);
   bool end_of_shrinking = current_display_width == display_area_.width();
+  int max_visible_panels = end_of_shrinking ?
+      max_visible_panels_ : max_visible_panels_on_hover_;
 
   // Update each overflow panel.
-  for (size_t i = 0; i < panels_.size(); ++i) {
+  for (int i = 0; i < num_panels(); ++i) {
     Panel* overflow_panel = panels_[i];
     gfx::Rect bounds = overflow_panel->GetBounds();
 
-    if (static_cast<int>(i) >= max_visible_panels_ && end_of_shrinking) {
+    if (i >= max_visible_panels) {
       bounds.set_width(0);
       bounds.set_height(0);
     } else {
       bounds.set_width(current_display_width);
       bounds.set_height(overflow_panel->IconOnlySize().height());
     }
 
     overflow_panel->SetPanelBoundsInstantly(bounds);
   }
+
+  // Update the indicator.
+  UpdateOverflowIndicator(current_display_width);

[jennb, 2011/12/20 02:08:23]

Count won't be changing during animation. Maybe UpdateOverflowIndicator is doing
too much in one function? Sometimes, you will only need to update the count and
not the bounds and sometimes, just the bounds. Perhaps separate the logic?

[jianli, 2011/12/20 22:08:10]

Separated the logic as suggested.

+}
+
+void PanelOverflowStrip::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  DCHECK(type == content::NOTIFICATION_APP_TERMINATING);
+
+  // The overflow indicator needs to be disposed when the last browser is

[jennb, 2011/12/20 02:08:23]

Don't need this if you destroy the indicator when panels are removed.

[jianli, 2011/12/20 22:08:10]

Removed.

+  // closed. Our destructor is called too late in the shutdown sequence.
+  if (overflow_indicator_.get())
+    overflow_indicator_.reset();
 }
 
 void PanelOverflowStrip::OnFullScreenModeChanged(bool is_full_screen) {
   for (size_t i = 0; i < panels_.size(); ++i)
     panels_[i]->FullScreenModeChanged(is_full_screen);
 }