Add KEEP_SIZE state to notification panel and fixed misc bugs.

chrome/browser/chromeos/notifications/notification_panel.cc

 // Copyright (c) 2010 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.
 
 // Draws the view for the balloons.
 
 #include "chrome/browser/chromeos/notifications/notification_panel.h"
 
 #include "app/gfx/canvas.h"
 #include "app/l10n_util.h"
@@ skipping 24 matching lines @@
 class PanelWidget : public views::WidgetGtk {
  public:
   explicit PanelWidget(chromeos::NotificationPanel* panel)
       : WidgetGtk(views::WidgetGtk::TYPE_WINDOW),
         panel_(panel) {
   }
 
   // views::WidgetGtk overrides.
   virtual gboolean OnMotionNotify(GtkWidget* widget, GdkEventMotion* event) {
     gboolean result = WidgetGtk::OnMotionNotify(widget, event);
-    panel_->DontUpdatePanelOnStale();
+    panel_->OnMouseMotion();
     return result;
   }
 
   virtual gboolean OnLeaveNotify(GtkWidget* widget, GdkEventCrossing* event) {
     gboolean result = views::WidgetGtk::OnLeaveNotify(widget, event);
     // Leave notify can happen if the mouse moves into the child gdk window.
     // Make sure the mouse is outside of the panel.
     gfx::Point p(event->x_root, event->y_root);
     gfx::Rect bounds;
     GetBounds(&bounds, true);
@@ skipping 16 matching lines @@
 
   virtual ~BalloonSubContainer() {}
 
   // views::View overrides.
   virtual gfx::Size GetPreferredSize() {
     return preferred_size_;
   }
 
   virtual void Layout() {
     // Layout bottom up
-    int count = GetChildViewCount();
     int height = 0;
-    for (int i = count - 1; i >= 0; --i) {
+    for (int i = GetChildViewCount() - 1; i >= 0; --i) {
       views::View* child = GetChildViewAt(i);
       child->SetBounds(0, height, child->width(), child->height());
       height += child->height() + margin_;
     }
     SchedulePaint();
   }
 
   // Updates the bound so that it can show all balloons.
   void UpdateBounds() {
     int height = 0;
     int max_width = 0;
     for (int i = GetChildViewCount() - 1; i >= 0; --i) {
-      views::View* c = GetChildViewAt(i);
-      height += c->height() + margin_;
-      max_width = std::max(max_width, c->width());
+      views::View* child = GetChildViewAt(i);
+      height += child->height() + margin_;
+      max_width = std::max(max_width, child->width());
     }
     if (height > 0)
       height -= margin_;
     preferred_size_.set_width(max_width);
     preferred_size_.set_height(height);
     SizeToPreferredSize();
   }
 
   // Returns the bounds that covers new notifications.
   gfx::Rect GetNewBounds() {
     gfx::Rect rect;
     for (int i = GetChildViewCount() - 1; i >= 0; --i) {
       BalloonViewImpl* view =
           static_cast<BalloonViewImpl*>(GetChildViewAt(i));
       if (!view->stale()) {
         if (rect.IsEmpty()) {
           rect = view->bounds();
         } else {
-          rect = rect.Union(bounds());
+          rect = rect.Union(view->bounds());
         }
       }
     }
     return gfx::Rect(x(), y(), rect.width(), rect.height());
   }
 
   // Returns # of new notifications.
   int GetNewCount() {
     int count = 0;
     for (int i = GetChildViewCount() - 1; i >= 0; --i) {
@@ skipping 47 matching lines @@
         0, sticky_container_->bounds().bottom() + margin,
         width(), non_sticky_container_->height());
   }
 
   virtual gfx::Size GetPreferredSize() {
     return preferred_size_;
   }
 
   // Returns the size that covers sticky and new notifications.
   gfx::Size GetStickyNewSize() {
-    gfx::Rect new_sticky = sticky_container_->bounds();
+    gfx::Rect sticky = sticky_container_->bounds();
     gfx::Rect new_non_sticky = non_sticky_container_->GetNewBounds();
-    if (new_sticky.IsEmpty())
+    if (sticky.IsEmpty())
       return new_non_sticky.size();
     if (new_non_sticky.IsEmpty())
-      return new_sticky.size();
-    return new_sticky.Union(new_non_sticky).size();
+      return sticky.size();
+    return sticky.Union(new_non_sticky).size();
   }
 
   // Adds a ballon to the panel.
   void Add(Balloon* balloon) {
     BalloonViewImpl* view =
         static_cast<BalloonViewImpl*>(balloon->view());
     GetContainerFor(balloon)->AddChildView(view);
   }
 
   // Updates the position of the |balloon|.
@@ skipping 22 matching lines @@
     GetContainerFor(balloon)->RemoveChildView(view);
   }
 
   // Returns the number of notifications added to the panel.
   int GetNotificationCount() {
     return sticky_container_->GetChildViewCount() +
         non_sticky_container_->GetChildViewCount();
   }
 
   // Returns the # of new notifications.
-  bool GetNewNotificationCount() {
+  int GetNewNotificationCount() {
     return sticky_container_->GetNewCount() +
         non_sticky_container_->GetNewCount();
   }
 
+  // Returns the # of sticky and new notifications.
+  int GetStickyNewNotificationCount() {
+    return sticky_container_->GetChildViewCount() +
+        non_sticky_container_->GetNewCount();
+  }
+
   // Returns the # of sticky notifications.
-  bool GetStickyNotificationCount() {
+  int GetStickyNotificationCount() {
     return sticky_container_->GetChildViewCount();
   }
 
   // Returns true if the |view| is contained in the panel.
   bool HasBalloonView(View* view) {
     return sticky_container_->HasChildView(view) ||
         non_sticky_container_->HasChildView(view);
   }
 
   // Updates the bounds so that all notifications are visible.
@@ skipping 32 matching lines @@
   BalloonSubContainer* non_sticky_container_;
   gfx::Size preferred_size_;
 
   DISALLOW_COPY_AND_ASSIGN(BalloonContainer);
 };
 
 NotificationPanel::NotificationPanel()
     : balloon_container_(NULL),
       state_(CLOSED),
       task_factory_(this),
-      update_panel_on_mouse_leave_(false),
-      latest_token_(0),
-      stale_token_(0) {
+      min_bounds_(0, 0, kBalloonMinWidth, kBalloonMinHeight) {
   Init();
 }
 
 NotificationPanel::~NotificationPanel() {
   Hide();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NottificationPanel public.
 
 void NotificationPanel::Show() {
   if (!panel_widget_.get()) {
     // TODO(oshima): Using window because Popup widget behaves weird
     // when resizing. This needs to be investigated.
     panel_widget_.reset(new PanelWidget(this));
     gfx::Rect bounds = GetPreferredBounds();
-    if (bounds.width() < kBalloonMinWidth ||
-        bounds.height() < kBalloonMinHeight) {
-      // Gtk uses its own default size when the size is empty.
-      // Use the minimum size as a default.
-      bounds.SetRect(0, 0, kBalloonMinWidth, kBalloonMinHeight);
-    }
+    bounds = bounds.Union(min_bounds_);
     panel_widget_->Init(NULL, bounds);
     // TODO(oshima): I needed the following code in order to get sizing
     // reliably. Investigate and fix it in WidgetGtk.
     gtk_widget_set_size_request(GTK_WIDGET(panel_widget_->GetNativeView()),
                                 bounds.width(), bounds.height());
     panel_widget_->SetContentsView(scroll_view_.get());
     panel_controller_.reset(
         new PanelController(this,
                             GTK_WINDOW(panel_widget_->GetNativeView()),
                             gfx::Rect(0, 0, kBalloonMinWidth, 1)));
   }
   panel_widget_->Show();
 }
 
 void NotificationPanel::Hide() {
   if (panel_widget_.get()) {
     // We need to remove & detach the scroll view from hierarchy to
     // avoid GTK deleting child.
     // TODO(oshima): handle this details in WidgetGtk.
     panel_widget_->GetRootView()->RemoveChildView(scroll_view_.get());
     panel_widget_.release()->Close();
     panel_controller_.release()->Close();
   }
 }
 
-int NotificationPanel::GetStickyNotificationCount() const {
-  return balloon_container_->GetStickyNotificationCount();
-}
-
-int NotificationPanel::GetNewNotificationCount() const {
-  return balloon_container_->GetNewNotificationCount();
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // BalloonCollectionImpl::NotificationUI overrides.
 
 void NotificationPanel::Add(Balloon* balloon) {
   balloon_container_->Add(balloon);
-  if (state_ == CLOSED || state_ == MINIMIZED)
+  if (state_ == CLOSED || state_ == MINIMIZED || state_ == KEEP_SIZE)
     state_ = STICKY_AND_NEW;
   Show();
   UpdatePanel(true);
   StartStaleTimer(balloon);
 }
 
 bool NotificationPanel::Update(Balloon* balloon) {
   if (balloon_container_->Update(balloon)) {
     if (state_ == CLOSED || state_ == MINIMIZED)
       state_ = STICKY_AND_NEW;
     Show();
     UpdatePanel(true);
     StartStaleTimer(balloon);
     return true;
   } else {
     return false;
   }
 }
 
 void NotificationPanel::Remove(Balloon* balloon) {
   balloon_container_->Remove(balloon);
   // no change to the state
   if (balloon_container_->GetNotificationCount() == 0)
     state_ = CLOSED;
-  if (static_cast<BalloonViewImpl*>(balloon->view())->closed_by_user()) {
-    DontUpdatePanelOnStale();
+  if (state_ == KEEP_SIZE) {
+    // Just update the content.
     balloon_container_->UpdateBounds();
     scroll_view_->Layout();
   } else {
     UpdatePanel(true);
   }
 }
 
 void NotificationPanel::ResizeNotification(
     Balloon* balloon, const gfx::Size& size) {
   // restrict to the min & max sizes
@@ skipping 19 matching lines @@
 }
 
 void NotificationPanel::ClosePanel() {
   state_ = CLOSED;
   UpdatePanel(false);
 }
 
 void NotificationPanel::OnPanelStateChanged(PanelController::State state) {
   switch (state) {
     case PanelController::EXPANDED:
-      // Geting expanded in STICKY_AND_NEW state means that a new
-      // notification is added, so just leave the state. Otherwise,
-      // expand to full.
-      if (state_ != STICKY_AND_NEW)
+      // Geting expanded in STICKY_AND_NEW or in KEEP_SIZE state means
+      // that a new notification is added, so just leave the
+      // state. Otherwise, expand to full.
+      if (state_ != STICKY_AND_NEW && state_ != KEEP_SIZE)
         state_ = FULL;
       // When the panel is to be expanded, we either show all, or
       // show only sticky/new, depending on the state.
       UpdatePanel(false);
       break;
     case PanelController::MINIMIZED:
       state_ = MINIMIZED;
       // Make all notifications stale when a user minimize the panel.
       balloon_container_->MakeAllStale();
       break;
   }
 }
 
 void NotificationPanel::OnMouseLeave() {
-  if (update_panel_on_mouse_leave_) {
-    // TODO(oshima): We need "AS_IS" state, which simply
-    // keeps the current panel size unless it has less notifications
-    // than it can show.
-    if (balloon_container_->GetStickyNotificationCount() > 0 ||
-        balloon_container_->GetNewNotificationCount() > 0) {
-      state_ = STICKY_AND_NEW;
-    } else {
-      state_ = MINIMIZED;
-    }
-    UpdatePanel(true);
+  if (balloon_container_->GetNotificationCount() == 0) {
+    state_ = CLOSED;
   }
+  UpdatePanel(true);
+}
+
+void NotificationPanel::OnMouseMotion() {
+  state_ = KEEP_SIZE;
+}
+
+NotificationPanelTester* NotificationPanel::GetTester() {
+  if (!tester_.get()) {
+    tester_.reset(new NotificationPanelTester(this));
+  }
+  return tester_.get();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NotificationPanel private.
 
 void NotificationPanel::Init() {
   DCHECK(!panel_widget_.get());
   balloon_container_ = new BalloonContainer(1);
   balloon_container_->set_background(
       views::Background::CreateSolidBackground(ResourceBundle::frame_color));
 
   scroll_view_.reset(new views::ScrollView());
   scroll_view_->set_parent_owned(false);
   scroll_view_->SetContents(balloon_container_);
   scroll_view_->set_background(
       views::Background::CreateSolidBackground(SK_ColorWHITE));
 }
 
 void NotificationPanel::UpdatePanel(bool contents_changed) {
-  update_panel_on_mouse_leave_ = false;
   if (contents_changed) {
     balloon_container_->UpdateBounds();
     scroll_view_->Layout();
   }
   switch(state_) {
+    case KEEP_SIZE: {
+      gfx::Rect min_bounds = GetPreferredBounds();
+      gfx::Rect panel_bounds;
+      panel_widget_->GetBounds(&panel_bounds, true);
+      if (min_bounds.height() < panel_bounds.height())
+        panel_widget_->SetBounds(min_bounds);
+      // no change.
+      break;
+    }
     case CLOSED:
       balloon_container_->MakeAllStale();
       Hide();
       break;
     case MINIMIZED:
       balloon_container_->MakeAllStale();
       if (panel_controller_.get())
         panel_controller_->SetState(PanelController::MINIMIZED);
       break;
     case FULL:
@@ skipping 11 matching lines @@
   }
 }
 
 gfx::Rect NotificationPanel::GetPreferredBounds() {
   gfx::Size pref_size = balloon_container_->GetPreferredSize();
   int new_height = std::min(pref_size.height(), kMaxPanelHeight);
   int new_width = pref_size.width();
   // Adjust the width to avoid showing a horizontal scroll bar.
   if (new_height != pref_size.height())
     new_width += scroll_view_->GetScrollBarWidth();
-  return gfx::Rect(0, 0, new_width, new_height);
+  return gfx::Rect(0, 0, new_width, new_height).Union(min_bounds_);
 }
 
 gfx::Rect NotificationPanel::GetStickyNewBounds() {
   gfx::Size pref_size = balloon_container_->GetPreferredSize();
   gfx::Size sticky_size = balloon_container_->GetStickyNewSize();
   int new_height = std::min(sticky_size.height(), kMaxPanelHeight);
   int new_width = pref_size.width();
   // Adjust the width to avoid showing a horizontal scroll bar.
   if (new_height != pref_size.height())
     new_width += scroll_view_->GetScrollBarWidth();
-  return gfx::Rect(0, 0, new_width, new_height);
-}
-
-void NotificationPanel::DontUpdatePanelOnStale() {
-  if (stale_token_ != latest_token_) {
-    stale_token_ = latest_token_;
-  }
-  update_panel_on_mouse_leave_ = true;
+  return gfx::Rect(0, 0, new_width, new_height).Union(min_bounds_);
 }
 
 void NotificationPanel::StartStaleTimer(Balloon* balloon) {
   BalloonViewImpl* view = static_cast<BalloonViewImpl*>(balloon->view());
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       task_factory_.NewRunnableMethod(
-          &NotificationPanel::OnStale, view, latest_token_++),
+          &NotificationPanel::OnStale, view),
       1000 * kStaleTimeoutInSeconds);
 }
 
-void NotificationPanel::OnStale(BalloonViewImpl* view, int token) {
+void NotificationPanel::OnStale(BalloonViewImpl* view) {
   if (balloon_container_->HasBalloonView(view) && !view->stale()) {
     view->set_stale();
     // don't update panel on stale
-    if (token < stale_token_) {
+    if (state_ == KEEP_SIZE)
       return;
-    }
-    if (balloon_container_->GetStickyNotificationCount() > 0) {
+    if (balloon_container_->GetStickyNewNotificationCount() > 0) {
       state_ = STICKY_AND_NEW;
     } else {
       state_ = MINIMIZED;
     }
     UpdatePanel(false);
   }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// NotificationPanelTester public.
+
+int NotificationPanelTester::GetNotificationCount() const {
+  return panel_->balloon_container_->GetNotificationCount();
+}
+
+int NotificationPanelTester::GetStickyNotificationCount() const {
+  return panel_->balloon_container_->GetStickyNotificationCount();
+}
+
+int NotificationPanelTester::GetNewNotificationCount() const {
+  return panel_->balloon_container_->GetNewNotificationCount();
+}
+
+
 }  // namespace chromeos