position the balloons after closing in a way that will keep the next one's cl...

chrome/browser/notifications/balloon_collection.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.
 
 #include "chrome/browser/notifications/balloon_collection_impl.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "chrome/browser/notifications/balloon.h"
 #include "chrome/browser/notifications/balloon_host.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/window_sizer.h"
 #include "gfx/rect.h"
 #include "gfx/size.h"
 
 namespace {
 
 // Portion of the screen allotted for notifications. When notification balloons
 // extend over this, no new notifications are shown until some are closed.
 const double kPercentBalloonFillFactor = 0.7;
 
 // Allow at least this number of balloons on the screen.
 const int kMinAllowedBalloonCount = 2;
 
+// Delay from the mouse leaving the balloon collection before
+// there is a relayout, in milliseconds.
+const int kRepositionDelay = 300;
+
 }  // namespace
 
 // static
 // Note that on MacOS, since the coordinate system is inverted vertically from
 // the others, this actually produces notifications coming from the TOP right,
 // which is what is desired.
 BalloonCollectionImpl::Layout::Placement
     BalloonCollectionImpl::Layout::placement_ =
         Layout::VERTICALLY_FROM_BOTTOM_RIGHT;
 
-BalloonCollectionImpl::BalloonCollectionImpl() {
+BalloonCollectionImpl::BalloonCollectionImpl()
+#if USE_OFFSETS
+    : ALLOW_THIS_IN_INITIALIZER_LIST(reposition_factory_(this)),
+      added_as_message_loop_observer_(false)
+#endif
+{
 }
 
 BalloonCollectionImpl::~BalloonCollectionImpl() {
   STLDeleteElements(&balloons_);
 }
 
 void BalloonCollectionImpl::Add(const Notification& notification,
                                 Profile* profile) {
   Balloon* new_balloon = MakeBalloon(notification, profile);
   // The +1 on width is necessary because width is fixed on notifications,
   // so since we always have the max size, we would always hit the scrollbar
   // condition.  We are only interested in comparing height to maximum.
   new_balloon->set_min_scrollbar_size(gfx::Size(1 + layout_.max_balloon_width(),
                                                 layout_.max_balloon_height()));
   new_balloon->SetPosition(layout_.OffScreenLocation(), false);
   new_balloon->Show();
+#if USE_OFFSETS
+  if (balloons_.size() > 0)
+    new_balloon->set_offset(balloons_[balloons_.size() - 1]->offset());
+#endif
 
   balloons_.push_back(new_balloon);
   PositionBalloons(false);
 
   // There may be no listener in a unit test.
   if (space_change_listener_)
     space_change_listener_->OnBalloonSpaceChanged();
 }
 
 bool BalloonCollectionImpl::Remove(const Notification& notification) {
@@ skipping 30 matching lines @@
 }
 
 void BalloonCollectionImpl::DisplayChanged() {
   layout_.RefreshSystemMetrics();
   PositionBalloons(true);
 }
 
 void BalloonCollectionImpl::OnBalloonClosed(Balloon* source) {
   // We want to free the balloon when finished.
   scoped_ptr<Balloon> closed(source);
-  for (Balloons::iterator it = balloons_.begin(); it != balloons_.end(); ++it) {
+  Balloons::iterator it = balloons_.begin();
+
+#if USE_OFFSETS
+  gfx::Point offset;
+  bool apply_offset = false;
+  while (it != balloons_.end()) {
+    if (*it == source) {
+      it = balloons_.erase(it);
+      if (it != balloons_.end()) {
+        apply_offset = true;
+        offset.set_y((source)->offset().y() - (*it)->offset().y() +
+            (*it)->content_size().height() - source->content_size().height());
+      }
+    } else {
+      if (apply_offset)
+        (*it)->add_offset(offset);
+      ++it;
+    }
+  }
+  // Start listening for UI events so we cancel the offset when the mouse
+  // leaves the balloon area.
+  if (apply_offset)
+    AddMessageLoopObserver();
+#else
+  for (; it != balloons_.end(); ++it) {
     if (*it == source) {
       balloons_.erase(it);
       break;
     }
   }
+#endif
+
   PositionBalloons(true);
 
   // There may be no listener in a unit test.
   if (space_change_listener_)
     space_change_listener_->OnBalloonSpaceChanged();
 }
 
 void BalloonCollectionImpl::PositionBalloons(bool reposition) {
   gfx::Point origin = layout_.GetLayoutOrigin();
   for (Balloons::iterator it = balloons_.begin(); it != balloons_.end(); ++it) {
-    gfx::Point upper_left = layout_.NextPosition(
-        Layout::ConstrainToSizeLimits((*it)->GetViewSize()), &origin);
+    gfx::Point upper_left = layout_.NextPosition((*it)->GetViewSize(), &origin);
     (*it)->SetPosition(upper_left, reposition);
   }
 }
 
+#if USE_OFFSETS
+void BalloonCollectionImpl::AddMessageLoopObserver() {
+  if (!added_as_message_loop_observer_) {
+    MessageLoopForUI::current()->AddObserver(this);
+    added_as_message_loop_observer_ = true;
+  }
+}
+
+void BalloonCollectionImpl::RemoveMessageLoopObserver() {
+  if (added_as_message_loop_observer_) {
+    MessageLoopForUI::current()->RemoveObserver(this);
+    added_as_message_loop_observer_ = false;
+  }
+}
+
+void BalloonCollectionImpl::CancelOffsets() {
+  reposition_factory_.RevokeAll();
+
+  // Unhook from listening to all UI events.
+  RemoveMessageLoopObserver();
+
+  for (Balloons::iterator it = balloons_.begin(); it != balloons_.end(); ++it)
+    (*it)->set_offset(gfx::Point(0, 0));
+
+  PositionBalloons(true);
+}
+
+void BalloonCollectionImpl::HandleMouseMoveEvent() {
+  if (!IsCursorInBalloonCollection()) {
+    // Mouse has left the region.  Schedule a reposition after
+    // a short delay.
+    if (reposition_factory_.empty()) {
+      MessageLoop::current()->PostDelayedTask(
+          FROM_HERE,
+          reposition_factory_.NewRunnableMethod(
+              &BalloonCollectionImpl::CancelOffsets),
+          kRepositionDelay);
+    }
+  } else {
+    // Mouse moved back into the region.  Cancel the reposition.
+    reposition_factory_.RevokeAll();
+  }
+}
+#endif
+
 BalloonCollectionImpl::Layout::Layout() {
   RefreshSystemMetrics();
 }
 
 void BalloonCollectionImpl::Layout::GetMaxLinearSize(int* max_balloon_size,
                                                      int* total_size) const {
   DCHECK(max_balloon_size && total_size);
 
   switch (placement_) {
     case VERTICALLY_FROM_TOP_RIGHT:
@@ skipping 94 matching lines @@
   gfx::Rect new_work_area = info_provider->GetPrimaryMonitorWorkArea();
 #endif
   if (!work_area_.Equals(new_work_area)) {
     work_area_.SetRect(new_work_area.x(), new_work_area.y(),
                        new_work_area.width(), new_work_area.height());
     changed = true;
   }
 
   return changed;
 }